Przewodnik po module kamery termowizyjnej MIPI: Integracja wysokorozdzielczego Edge AI z Raspberry Pi i dronami

Spójrzmy prawdzie w oczy: sprawienie, by wysokowydajne obrazowanie w podczerwieni współpracowało z wbudowanymi systemami obliczeniowymi, od zawsze było ogromnym utrapieniem dla architektów systemów. Dawniej byliśmy skazani na prowadzenie wolnych linii SPI o niskiej przepustowości, użeranie się z nieporęcznymi, zastrzeżonymi interfejsami równoległymi lub przepalanie budżetów energetycznych prądożernymi, masywnymi konfiguracjami USB. Ale czasy się zmieniły. Pojawienie się MIPI CSI-2 (Mobile Industry Processor Interface Camera Serial Interface 2) standardu w dziedzinie niechłodzonych kamer LWIR (długa podczerwień) całkowicie zmieniło reguły gry, niwelując ogromny podział fizyczny i architektoniczny.

Przesyłając surowe, wysokorozdzielcze klatki termiczne bezpośrednio do procesora sygnału obrazu (ISP) lub GPU procesora głównego – całkowicie omijając typowe wąskie gardła USB i SPI – moduły termiczne z obsługą MIPI odblokowały uczenie maszynowe w czasie rzeczywistym z ultraniskimi opóźnieniami na brzegu sieci. Mówimy tu o uruchamianiu zaawansowanych modeli wykrywania obiektów na lekkim, mobilnym sprzęcie, takim jak Raspberry Pi 4/5 i NVIDIA Jetson Orin Nano, bez najmniejszego wysiłku.

Ten przewodnik integracyjny to Twój podręcznik terenowy. Niezależnie od tego, czy budujesz ładunki do dronów, konfigurujesz autonomiczne roboty fabryczne, czy projektujesz inteligentne centra monitorowania, ten dokument szczegółowo omawia układ sprzętowy na poziomie miedzi, konfiguracje sterowników i potoki oprogramowania potrzebne do połączenia wysokorozdzielczego modułu kamery termowizyjnej MIPI z nowoczesnymi procesorami głównymi. Przyjrzymy się również pod lupą niektórym rzeczywistym, komercyjnym modułom opartym na układach ASIC, abyś mógł zobaczyć, jak te koncepcje przekładają się na fizyczny sprzęt stworzony do pracy w trudnych warunkach.

MIPI CSI-2 a starsze interfejsy termiczne: Decydująca analiza architektoniczna

Aby zrozumieć, dlaczego bezpośrednie łącze termiczne MIPI CSI-2 jest jedynym rozsądnym wyborem dla wysokowydajnego uczenia maszynowego na brzegu sieci, przyjrzyjmy się, co dzieje się pod maską w porównaniu ze starszymi magistralami, takimi jak SPI, USB czy interfejsy równoległe (DVP).

Oto sedno sprawy ze starszym sprzętem: w przypadku USB lub SPI surowe klatki termiczne muszą pokonać długą, okrężną drogę. Dane są przepychane przez pośredni kontroler USB lub układ mostkowy, wędrują kablem i trafiają na stos oprogramowania systemu operacyjnego hosta. Oznacza to, że CPU jest nieustannie przerywane, aby przetwarzać pakiety USB, zmuszając systemy do akceptowania ogromnych kar za opóźnienia, wysokiego obciążenia CPU i grubszych wiązek przewodów fizycznych.

Bezpośrednia konfiguracja MIPI podłączona do magistrali zmienia to wszystko. Łączy ona rdzeń niechłodzonego czujnika termicznego bezpośrednio z wbudowanym, niestandardowym układem ASIC. Stamtąd dane płyną dedykowanym, ekranowanym przed zakłóceniami kablem taśmowym MIPI CSI-2 prosto do fizycznego portu wejścia wideo układu Host System on Chip (SoC). Dzięki sprzętowemu DMA (bezpośredniemu dostępowi do pamięci) te przychodzące surowe 14-bitowe (Y14) macierze wideo są zrzucane bezpośrednio do pamięci systemowej, bez pytania głównych rdzeni CPU o pozwolenie. Rezultat? Fizyczne opóźnienie poniżej milisekundy.

Wysoka przepustowość i minimalne opóźnienia

Protokół MIPI CSI-2 działa w oparciu o warstwę fizyczną MIPI D-PHY warstwa fizyczna, wykorzystująca szybkie pary sygnałów różnicowych składające się z jednej dedykowanej linii zegara i maksymalnie czterech linii danych. Nawet podstawowa, jednoliniowa konfiguracja D-PHY v1.1 zapewnia solidne 1,5 Gb/s surowej przepustowości fizycznej.

Porównaj to z SPI, które osiąga ścianę w okolicach 50 MHz (efektywnie 50 Mb/s). Jasne, SPI poradzi sobie z małą, niskorozdzielczą termiczną zabawką 160 x 120 działającą przy powolnych 9 Hz. Jeśli jednak pracujesz nad profesjonalnym sensorem o rozdzielczości 640 x 512, generującym 30 klatek na sekundę przy pełnej 14-bitowej głębi radiometrycznej, masz do czynienia z poważną matematyką:

Szybkość transmisji danych = 640 × 512 × 30 klatek/s × 14 bitów/piksel ≈ 137,6 Mb/s

Nie da się tego przepchnąć przez magistralę SPI bez poważnego tłumienia sygnału, przesunięcia zegara i błędów synchronizacji. A próba przesłania tej surowej matrycy przez USB 2.0 opakowuje pakiety wideo w złożone ramki protokołu, podbijając użycie CPU do poziomów krytycznych. MIPI CSI-2 zachowuje prostotę, kierując surowe piksele bezpośrednio, pozbywając się balastu protokołu i redukując opóźnienie od szkła do pamięci niemal do zera.

W krytycznych, rzeczywistych zastosowaniach, takich jak unikanie kolizji w autonomicznych bezzałogowych statkach powietrznych (UAV), surowa prędkość akwizycji może dosłownie decydować o powodzeniu misji lub całkowitej katastrofie. W przypadku użycia interfejsu MIPI, układ SoC otrzymuje status niechłodzonego czujnika mikrobolometrycznego klatka po klatce z zerowym opóźnieniem, zapewniając algorytmom oprogramowania szybkość potrzebną do wykrywania przeszkód i natychmiastowej korekty kursu.

Wnętrze sprzętu: Przetwarzanie ASIC i ścieżka sygnałowa niechłodzonego mikrobolometru LWIR

Zdejmijmy metalową osłonę i spójrzmy na krzem. Wysokiej klasy modułu kamery termowizyjnej MIPI konfiguracja to precyzyjny instrument elektrooptyczny. Jego zadaniem jest przechwytywanie długofalowego promieniowania podczerwonego (w zakresie od 8 μm do 14 μm) i przekształcanie tych fotonów w czyste, zserializowane pakiety cyfrowe gotowe dla procesora głównego.

Najpierw światło podczerwone przechodzi przez profesjonalną soczewkę germanową (Ge), na przykład stałoogniskową 9 mm. Ponieważ zwykłe szkło blokuje promieniowanie LWIR, german jest tutaj materiałem z wyboru. Soczewka skupia tę energię cieplną na matrycy płaszczyzny ogniskowej (FPA) wypełnionej niechłodzonymi mikrobolometrami z tlenku wanadu (VOx) lub diod krzemowych.

Każdy piksel w tej matrycy to mikroskopijna struktura mostkowa zawieszona nad krzemem. Gdy foton podczerwieni uderza w ten mostek, temperatura membrany zmienia się, zmieniając jej opór elektryczny. Układ scalony odczytu (ROIC) połączony bezpośrednio pod matrycą mikrobolometrów skanuje te zmiany, przykłada prądy polaryzacji i przekształca te sygnały analogowe w surowe cyfrowe wartości o wysokiej rozdzielczości za pomocą wbudowanych przetworników analogowo-cyfrowych (zazwyczaj generujących 14-bitowe lub 16-bitowe wartości surowe).

Kluczowa rola wbudowanego układu ASIC

Próba przesłania surowych danych z mikrobolometru bezpośrednio do procesora głównego bez ich wcześniejszego oczyszczenia spowodowałaby przeciążenie procesora. Surowe dane z mikrobolometru są niezwykle zaszumione: pełne przestrzennych niejednorodności, martwych pikseli i szumu termicznego. Dlatego wysokiej klasy termiczne rdzenie MIPI wykorzystują wbudowany układ scalony specyficznego przeznaczenia (ASIC) do obsługi najbardziej wymagających zadań, zanim piksele trafią na linie MIPI.

Oto podstawowe etapy przetwarzania sprzętowego, które układ ASIC wykonuje w czasie rzeczywistym:

⚙️ Korekcja niejednorodności (NUC): Ten etap kompensuje dryft między pikselami. Z czasem wewnętrzne ciepło kamery powoduje, że piksele raportują różne wartości. Układ ASIC stosuje macierze wzmocnienia i offsetu w czasie rzeczywistym, tymczasowo uruchamiając wewnętrzną fizyczną przesłonę w celu ustalenia linii bazowej punktu zerowego.
⚙️ Zastępowanie uszkodzonych pikseli (BPR): Gdy piksel mikrobolometru ulegnie uszkodzeniu lub się zatnie, układ ASIC interpoluje dane z otaczających pikseli, aby zamaskować to w locie.
⚙️ Filtrowanie przestrzenne i czasowe: Wykorzystuje to algorytmy trójwymiarowej adaptacyjnej redukcji szumów, aby obniżyć różnicę temperatur równoważną szumom (NETD) urządzenia, dzięki czemu obraz jest ostry nawet w scenach, gdzie wszystko ma mniej więcej tę samą temperaturę.
⚙️ Automatyczna regulacja wzmocnienia (AGC) i kompresja zakresu dynamicznego (DRC): Aby uzyskać obraz czytelny dla człowieka, nie można po prostu wyświetlić surowego strumienia 14-bitowego. Układ ASIC kompresuje ten ogromny zakres dynamiczny do wysokokontrastowego wyjścia 8-bitowego (przy użyciu algorytmów kontrastu przestrzennego, takich jak CLAHE).
⚙️ Wstawianie metadanych telemetrycznych i radiometrycznych: Układ ASIC osadza obliczone wartości temperatury bezpośrednio w liniach wygaszania każdego pakietu wideo. Pozwala to kodowi na odpytywanie dokładnego oszacowania temperatury dowolnego pojedynczego piksela bez konieczności analizowania całkowicie oddzielnego strumienia danych.

Po przetworzeniu układ ASIC pakuje te dane w czyste ramki MIPI (często w formatach 14-bit raw, UYVY lub RGB). Fizyczne nadajniki D-PHY serializują te dane i przesyłają je przez szybkie różnicowe linie transmisyjne. Tymczasem polecenia konfiguracyjne, poprawki rejestrów i komendy wędrują tam i z powrotem przez interfejs sterowania kamerą (CCI) — który w rzeczywistości jest po prostu standardową linią zegara I2C w trybie szybkim, pracującą z częstotliwością do 400 kHz.

Integracja wbudowana: Konfiguracja sterownika, drzewa urządzeń i potoku V4L2 krok po kroku

Jeśli pracujesz w warsztacie nad podłączeniem jednego z tych modułów do płytki wbudowanej, takiej jak BCM2711/BCM2712 (znajdującej się w Raspberry Pi 4/5) lub NVIDIA Jetson, musisz upewnić się, że wyprowadzenia sprzętowe, drzewo urządzeń i warstwy V4L2 są ze sobą zgodne.

Mapowanie wyprowadzeń fizycznych

W większości konfiguracji rdzeń czujnika łączy się z hostem za pomocą cienkiego, 15- lub 22-pinowego elastycznego kabla taśmowego (FPC). Upewnij się, że dokładnie odwzorowujesz te linie na swojej płytce:

⚙️ VCC (linie zasilające): Zwykle wymaga oddzielnych linii zasilania rdzenia 3,3 V, 1,8 V, a czasami 1,2 V.
⚙️ GND: Kluczowe jest owinięcie wysokoczęstotliwościowych mas ekranujących wokół różnicowych linii zegara i danych, aby całkowicie wyeliminować przesłuchy.
⚙️ MCLK (zegar główny): Sygnał $24\text{ MHz} - 27\text{ MHz}$ dostarczany przez hosta do napędzania wewnętrznej maszyny stanów układu ASIC.
⚙️ I2C SDA / SCL (CCI): Steruje odczytami i zapisami rejestrów.
⚙️ MIPI CLKP / CLKN: Różnicowa para linii zegara.
⚙️ MIPI D0P/N i D1P/N: Dwie linie różnicowych par danych do transmisji.
⚙️ PWDN / RESET: Standardowe piny GPIO do twardego wyłączania zasilania i resetowania układu ASIC.

Integracja drzewa urządzeń (plik źródłowy DTSI)

Aby poinformować jądro Linuksa, że na fizycznym porcie CSI nasłuchuje rdzeń kamery, musisz napisać i skompilować nakładkę drzewa urządzeń (.dtbo). Oto przetestowany plik drzewa urządzeń, który możesz dostosować, aby zarejestrować rdzeń termiczny sterowany przez ASIC pod adresem I2C 0x30:

/dts-v1/;

Weryfikacja podsystemu V4L2 i sterowanie potokiem

Po skompilowaniu tej nakładki i uruchomieniu systemu standardowe sterowniki Linuksa powinny wykryć kamerę MIPI i zmapować ją bezpośrednio jako urządzenie Video4Linux2. Przeprowadźmy szybkie sprawdzenie w terminalu, aby potwierdzić, że magistrala fizyczna została poprawnie zarejestrowana:

# Zapytanie systemu w celu potwierdzenia dołączenia sterownika

Nasz konsola powinna wyświetlić coś takiego, co wskazuje, że odbiornik sprzętowy CSI przeanalizował nakładkę:

Unicam Video Capture (platform:fe801000.csi):

Teraz zapytajmy konkretny węzeł urządzenia, aby zobaczyć, jaką konfigurację danych pikseli wysyła wbudowany układ ASIC przez interfejs MIPI:

# List supported resolutions and pixel-formats
v4l2-ctl -d /dev/video0 --list-formats-ext

You should see formats for both raw data and clean, processed video streams:

ioctl: VIDIOC_ENUM_FMT
    Index       : 0
    Type        : Video Capture
    Pixel Format: 'Y14 ' (Private Raw 14-bit)
    Size: 640x512
        Interval: 0.033 s (30.000 fps)
    
    Index       : 1
    Type        : Video Capture
    Pixel Format: 'UYVY' (YUV 4:2:2 8-bit)
    Size: 640x512
        Interval: 0.033 s (30.000 fps)

If you want to grab some raw frames and dump them directly to disk without loading any heavy decoding libraries, run this terminal test command:

# Capture raw radiometric Y14 frames directly from the MIPI module
v4l2-ctl --device=/dev/video0 --set-fmt-video=width=640,height=512,pixelformat=Y14 --stream-mmap --stream-count=150 --stream-to=test_frames.raw

4. Python-Based Real-Time Capture and Radiometric Conversion Engine

To pull this stream into a real computer-vision pipeline, you can write a lightweight Python wrapper using OpenCV. This code will hook the frame stream, read the raw pixel counts, convert them to actual surface temperatures, and display a localized thermal layout:

import cv2
import numpy as np

class MIPIThermalCapture:
    def __init__(self, device_id=0, width=640, height=512):
        self.device_id = device_id
        self.width = width
        self.height = height
        
        # Open video device using V4L2 capture backend
        self.cap = cv2.VideoCapture(self.device_id, cv2.CAP_V4L2)
        if not self.cap.isOpened():
            raise RuntimeError(f"Failed to access thermal camera at /dev/video{device_id}")
            
        # Select the Raw Y14 format (this maps to raw pixel counts)
        self.cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'Y','1','4'))
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.width)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.height)

    def read_pixel_and_temperature_matrix(self):
        ret, frame = self.cap.read()
        if not ret:
            return False, None, None
            
        # Treat frame as raw uint16 array (since data is Y14 / raw-14 bit)
        raw_16bit = np.frombuffer(frame, dtype=np.uint16).reshape((self.height, self.width))
        
        # Convert raw digital counts (ADU) to physical temperature in Celsius
        # Assumes calibration scale: Temp in Celsius = (ADU * 0.04) - 273.15
        temperature_map = (raw_16bit.astype(np.float32) * 0.04) - 273.15
        
        # Map 14-bit range to 8-bit for display visualization
        normalized_8bit = cv2.normalize(raw_16bit, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
        colored_frame = cv2.applyColorMap(normalized_8bit, cv2.COLORMAP_JET)
        
        return True, colored_frame, temperature_map

    def release(self):
        self.cap.release()

if __name__ == "__main__":
    thermal = MIPIThermalCapture(device_id=0)
    try:
        print("[INFO] Initializing raw MIPI feed. Press 'q' to exit.")
        while True:
            success, display_img, temp_data = thermal.read_pixel_and_temperature_matrix()
            if not success:
                break
                
            # Query point temperature in the center of the frame (Coordinates x=320, y=256)
            center_temp = temp_data[256, 320]
            cv2.putText(display_img, f"Center Spot: {center_temp:.2f} C", (30, 40),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
            
            cv2.imshow("MIPI Thermal Real-Time Capture", display_img)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        thermal.release()
        cv2.destroyAllWindows()

Prezentacje produktów przemysłowych: Porównanie specyfikacji technicznych

When you are sourcing uncooled infrared sensors for a real product deployment, you have to weigh mechanical specs and interface types against your payload's size, weight, and power (SWaP) limits. Let's look at two commercial-grade, ultra-compact thermal cores designed to handle these integration challenges in the field.

Product Showcase 1: Mini2 640x512 9mm Thermal Imaging Camera Module For Drones

The Mini2 is an ultra-light, compact thermal core designed to slide onto micro-gimbals, commercial drone frames, and space-critical robotic limbs.

Technical Overview:
The Uncooled Infrared Mini2 640x512 9mm Thermal Imaging Camera Module For Drones is built from the ground up for weight-critical aerial payloads. By pairing a highly sensitive, uncooled VOx microbolometer array with a precision-milled 9mm lens, this module serves up incredibly sharp, long-range thermal imagery. Because it drops raw radiometric measurements and filtered frames straight out of its on-board MIPI CSI-2 interface, you bypass bulky, power-hungry USB converters. That translates to longer flight times, fewer payload stabilization issues, and clean tracking metrics on target.

Zobacz szczegóły produktu i ceny ➔

Product Showcase 2: ASIC Thermal Sensor Camera Module

This module pairs an industrial-grade uncooled core with a highly versatile interface board, making it perfect for fixed security systems, network monitoring, and plant safety arrays.

Technical Overview:
The Uncooled Infrared RJ45 CVBS RTSP IP 640*512 Thermal Sensor Camera Module is built around a heavy-duty ASIC processing core to run continuously in demanding environments. This module stands out because it packs native networking hardware. You get RJ45 capabilities to stream video directly over RTSP/RTMP, combined with CVBS analog video lines to hook up directly to legacy security monitors. If you are building a larger industrial monitoring system or a facility fire-watch net, this multi-port flexibility saves you from having to daisy-chain external system controllers.

Zobacz szczegóły produktu i ceny ➔

Comparative Specifications Matrix

Let's map these two cores side-by-side so you can see how their hardware profiles line up with your design targets:

Archetypy wdrożeń Edge AI i systemów lotniczych

Taking a raw, uncooled MIPI core and sticking it on an active, autonomous drone frame introduces physical and electrical challenges. To avoid field failures, you must keep these key physical factors in mind:

Electromagnetic Shielding (EMI Protection)

Drones are packed with noisy electronics. Modern multi-rotor speed controllers (ESCs), telemetry lines running on 915 MHz, and digital video transmitters throw out a lot of high-frequency noise. Standard camera ribbon cables act like antennas, catching this interference and dropping packets, causes frame freezes or physical bus lockups.

To avoid this, wrap your physical flex lines with copper or aluminum shielding tapes, and make sure to ground that shield directly to your drone's central carbon frame. This channels noise away from sensitive high-speed lines, keeping your signal clean.

Low-Noise Power Distribution

When your drone hits the throttle, the battery drops voltage or spikes. Uncooled microbolometers are highly sensitive to power input fluctuations. If your power line is noisy, you'll see horizontal banding across your thermal video.

To prevent this, use a dedicated, high-PSRR (Power Supply Rejection Ratio) low-dropout linear regulator (LDO) to feed the thermal core. This decouples the sensor's analog inputs from battery drops and motor-switching noise.

Mechanical Vibration Isolation

UAV motors and props create high-frequency micro-vibrations. These vibrations cause physical distortion and motion blur in thermal images, and can put stress on physical flex cable connections over time.

To fix this, utilize soft elastomer damping balls (aim for a 30A to 40A shore hardness rating) on your sensor mounts. This keeps the camera isolated and protects your 12-micron spatial resolution from getting smeared during high-speed flights.

Designing the Real-Time AI Inference Pipeline

Using a direct MIPI interface with a powerful companion processor (like the Jetson Orin Nano) allows you to run modern object detection models like YOLOv8 on the fly. This workflow is highly effective for search and rescue operations, structural checks, or automated security patrols.

Since MIPI bypasses clunky USB conversion layers, raw frames stream into memory with almost zero delay. Below is an integration-ready Python wrapper using NVIDIA's TensorRT execution engine to run high-speed inference on raw thermal frames:

import sys
import time
import numpy as np
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import cv2

# TensorRT Inference Wrapper for Edge SoC platforms
class HighSpeedThermalYOLO:
    def __init__(self, engine_path):
        self.logger = trt.Logger(trt.Logger.WARNING)
        with open(engine_path, "rb") as f, trt.Runtime(self.logger) as runtime:
            self.engine = runtime.deserialize_cuda_engine(f.read())
        self.context = self.engine.create_execution_context()
        
        # Allocate Host and Device buffers
        self.inputs, self.outputs, self.bindings, self.stream = self.allocate_buffers()

    def allocate_buffers(self):
        inputs = []
        outputs = []
        bindings = []
        stream = cuda.Stream()
        for binding in self.engine:
            size = trt.volume(self.engine.get_binding_shape(binding)) * 1
            dtype = trt.nptype(self.engine.get_binding_dtype(binding))
            # Allocate Host Pin page-locked memory
            host_mem = cuda.pagelocked_empty(size, dtype)
            # Allocate Device GPU Memory
            device_mem = cuda.mem_alloc(host_mem.nbytes)
            bindings.append(int(device_mem))
            if self.engine.binding_is_input(binding):
                inputs.append({'host': host_mem, 'device': device_mem})
            else:
                outputs.append({'host': host_mem, 'device': device_mem})
        return inputs, outputs, bindings, stream

    def run_inference(self, frame_input):
        # Resize raw image and normalize values to 0.0 - 1.0 range
        resized = cv2.resize(frame_input, (640, 512))
        normalized = resized.astype(np.float32) / 255.0
        
        # Flatten image array and copy to driver host memory
        self.inputs[0]['host'] = np.ascontiguousarray(normalized)
        
        # Copy input data to GPU device memory
        cuda.memcpy_htod_async(self.inputs[0]['device'], self.inputs[0]['host'], self.stream)
        # Execute model asynchronously
        self.context.execute_async_v2(bindings=self.bindings, stream_handle=self.stream.handle)
        # Copy output back to Host memory
        cuda.memcpy_dtoh_async(self.outputs[0]['host'], self.outputs[0]['device'], self.stream)
        
        self.stream.synchronize()
        return self.outputs[0]['host']

if __name__ == "__main__":
    print("[INIT] Loading TensorRT Deep Inference Network...")
    # thermal_detector = HighSpeedThermalYOLO("models/yolov8s_thermal.engine")
    print("[OK] Execution engine loaded. Ready to receive high-speed thermal frames from MIPI kernel.")

Pogłębione FAQ dla deweloperów (Rozwiązywanie problemów technicznych)