💣 🕛 ✝️ Nachtsichtgerät basierend auf dem Wärmebildmodul Flir Lepton 3 👲🏽 🔖 ✒️

Zuvor habe ich einen Artikel über den Anschluss einer Wärmebild-Set-Top-Box an ein Flir One Gen 2-Smartphone geschrieben. Es ist an der Zeit, das Lepton-Modul aus dieser Set-Top-Box zu entfernen und es direkt an den Mikrocontroller anzuschließen, indem ein Nachtsichtgerät mit einer Auflösung von 160 x 120 Pixel zusammengebaut wird.

Um Ihr eigenes Nachtsicht-Wärmebildgerät zu bauen, benötigen Sie:

1) Platine mit einem Mikrocontroller. Ich habe ein Board von einem chinesischen Freund mit dem Mikrocontroller STM32F407VGT6 genommen. So ein guter Controller: 168 MHz Frequenz und 192 KB RAM.

2) Anzeige. Ich habe ein Display mit einer Auflösung von 320x240 aufgenommen. Solche Anzeigen werden mit verschiedenen Controllern geliefert. Ich habe es mit dem hx8347d Controller bekommen.

3) Karte zum Anschließen von Lepton 3 an SPI und I2C.

4) Das Lepton selbst 3. Das schwierigste und teuerste Element. Um es zu bekommen, kaufte ich mir bei ebay eine fehlerhafte Flir One Gen 2 Wärmebildkamera und nahm ein Lepton heraus. Es sieht in Vergrößerung so aus:

Sie können Punkt 3 von dieser Liste ausschließen, es sei denn, Sie schaffen es natürlich, ein Kinderbett für ein Lepton von einer fehlerhaften Wärmebildkamera zu nehmen und es zu entlöten (und ihre Kontakte befinden sich übrigens von unten). Leider ist der Abstand zwischen den Beinen am Lepton recht gering, so dass mir diese Option nicht vorgelegt wurde.

Um all dies zu sammeln, müssen Sie es nur wie folgt löten:

Sie müssen auch die Stromversorgung anschließen. Um die Lepton-Karte mit Strom zu versorgen, verwende ich 5 V, für die STM32-Karte 3,3 V. Um 5 V von der Batterie zu erhalten, verwende ich den TEL3-0511-Wandler (Eingangsspannung von 4,5 bis 9 V) und reduziere diese 5 V auf einem normalen LP2950CZ-3.3 (übrigens Erhitzt bis zu 70 Grad. Auch hier müssen Sie einen DC / DC-Wandler verwenden, aber ich habe ihn noch nicht gekauft. Lepton 3 isst übrigens gut. Bei einer Stromversorgung von 6 V beträgt der Stromverbrauch des gesamten Geräts ca. 250 mA. Wenn der Lepton zur Kalibrierung auf den Verschluss klicken möchte, steigt der Strom auf 500 mA.

Alles zusammen sieht so aus:

Um mit einem Lepton arbeiten zu können, benötigen Sie ein Programm. Ich habe CubeMX und Keil 5 verwendet. In diesem Fall werden alle Software-Bindungen bis zur Unmöglichkeit vereinfacht.

Die Kommunikation mit einem Lepton erfolgt über SPI. Ich habe I2C nicht verwendet, da es keinen besonderen Bedarf gab. Laut I2C können Sie den Zustand des Leptons, seine Betriebsmodi, den automatischen Kalibrierungsmodus aktivieren / deaktivieren usw. Für ein Nachtsichtgerät ist dies jedoch nicht besonders erforderlich.

Um die Daten zu entschlüsseln, habe ich ein Modul geschrieben:

Modul

leptoncontrol.h

#ifndef LEPTON_CONTROL_H #define LEPTON_CONTROL_H #include <stdbool.h> #include <stdio.h> //   ( ) #define LEPTON_ORIGINAL_IMAGE_WIDTH 160 #define LEPTON_ORIGINAL_IMAGE_HEIGHT 120 //  VoSPI #define VOSPI_FRAME_HEIGHT 60 //  VoSPI #define VOSPI_FRAME_WIDTH 80 //  VoSPI   (164  RAW14  244  RGB) #define VOSPI_PACKAGE_SIZE 164 //   VoSPI   #define VOSPI_PACKAGE_LINE_SIZE 160 //  VOSPI   #define VOSPI_SEGMENT_LINE_AMOUNT 60 void LEPTONCONTROL_Init(void);// void LEPTONCONTROL_CalculateCRC(unsigned short *crc,unsigned char byte);// crc bool LEPTONCONTROL_PushVoSPI(unsigned char data[VOSPI_PACKAGE_SIZE],bool *first_line);//    VoSPI    unsigned short *LEPTONCONTROL_GetRAW14Ptr(void);//      #endif

leptoncontrol.c

 #include "leptoncontrol.h" #include "stm32f4xx_hal.h" static unsigned short RAW14Image[LEPTON_ORIGINAL_IMAGE_HEIGHT*LEPTON_ORIGINAL_IMAGE_WIDTH];//  static unsigned short CRCTable[256];//   CRC16 //     #define RESYNC_TIMEOUT_MS 19 //:   #define NO_SEGMENT -1 //:   #define ERROR_PACKAGE -2 //---------------------------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------------------------- void LEPTONCONTROL_Init(void) { //    CRC unsigned short code; for(long n=0;n<256;n++) { code=((unsigned short)n)<<8; for(unsigned char m=0;m<8;m++) { if(code&(1<<15)) code=(code<<1)^0x1021; else code=code<<1; } CRCTable[n]=code; } } //---------------------------------------------------------------------------------------------------- // crc //---------------------------------------------------------------------------------------------------- void LEPTONCONTROL_CalculateCRC(unsigned short *crc,unsigned char byte) { *crc=CRCTable[(((*crc)>>8)^byte++)&0xFF]^((*crc)<<8); } //---------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------- long LEPTONCONTROL_ReadSegment(unsigned short *raw14_ptr,unsigned char data[VOSPI_PACKAGE_SIZE],bool *first_line) { static long current_package=-1; static long segment=-1; long n; *first_line=false; if ((data[0]&0x0F)==0x0F) return(NO_SEGMENT);//  unsigned short crc=data[2]; crc<<=8; crc|=data[3]; // CRC unsigned short crc16=0; LEPTONCONTROL_CalculateCRC(&crc16,data[0]&0x0F); LEPTONCONTROL_CalculateCRC(&crc16,data[1]); LEPTONCONTROL_CalculateCRC(&crc16,0); LEPTONCONTROL_CalculateCRC(&crc16,0); for(n=4;n<VOSPI_PACKAGE_SIZE;n++) LEPTONCONTROL_CalculateCRC(&crc16,data[n]); if (crc16!=crc) return(ERROR_PACKAGE);// CRC //   unsigned short package=data[0]&0x0F; package<<=8; package|=data[1]; if (package==0) { *first_line=true; current_package=0; } if (package==20) { unsigned char ttt=(data[0]&0x70)>>4;//     20  segment=ttt; } if (current_package<0) return(NO_SEGMENT); if (current_package!=package) { current_package=-1; return(ERROR_PACKAGE); } unsigned short *raw_ptr=raw14_ptr+current_package*VOSPI_PACKAGE_LINE_SIZE/2; for(n=0;n<VOSPI_PACKAGE_LINE_SIZE/2;n++,raw_ptr++) { //    big-endian: ,  unsigned short value=data[n*sizeof(short)+4]; value<<=8; value|=data[n*sizeof(short)+5]; *raw_ptr=value; } current_package++; if (current_package!=VOSPI_FRAME_HEIGHT) return(NO_SEGMENT); current_package=-1; return(segment); } //---------------------------------------------------------------------------------------------------- //    VoSPI    //---------------------------------------------------------------------------------------------------- bool LEPTONCONTROL_PushVoSPI(unsigned char data[VOSPI_PACKAGE_SIZE],bool *first_line) { *first_line=false; static long waitable_segment=1; long segment=LEPTONCONTROL_ReadSegment(RAW14Image+(waitable_segment-1)*VOSPI_FRAME_WIDTH*VOSPI_SEGMENT_LINE_AMOUNT,data,first_line); if (segment==ERROR_PACKAGE) HAL_Delay(RESYNC_TIMEOUT_MS); if (segment==ERROR_PACKAGE || segment==0) waitable_segment=1; if (segment==ERROR_PACKAGE || segment==NO_SEGMENT || segment==0) return(false); if (segment!=waitable_segment) { waitable_segment=1; if (segment!=1) return(false); } waitable_segment++; if (waitable_segment!=5) return(false); waitable_segment=1; return(true); } //---------------------------------------------------------------------------------------------------- //      //---------------------------------------------------------------------------------------------------- unsigned short *LEPTONCONTROL_GetRAW14Ptr(void) { return(RAW14Image); }

Alle Arbeiten mit diesem Modul bestehen in der einfachen Übermittlung von Daten, die von SPI erhalten wurden.

Arbeiten Sie mit dem Modul

 while(1) { //   while(1) { HAL_SPI_Receive(&hspi1,buffer,VOSPI_PACKAGE_SIZE,0x1000); bool first_line=false; unsigned char *buffer_ptr=buffer; LEPTONCONTROL_PushVoSPI(buffer_ptr,&first_line); if (first_line==true) break; } //    lepton3 unsigned char *buffer_ptr=buffer; HAL_SPI_Receive(&hspi1,buffer_ptr,VOSPI_PACKAGE_SIZE*SPI_READ_VOSPI_AMOUNT,0x1000); buffer_ptr=buffer; for(long n=0;n<SPI_READ_VOSPI_AMOUNT;n++,buffer_ptr+=VOSPI_PACKAGE_SIZE) { bool first_line=false; bool res=LEPTONCONTROL_PushVoSPI(buffer_ptr,&first_line); if (res==true) CreateImage();//     } }

Nach dem Zusammenbau des Rahmens werden die Sensorwerte einfach normalisiert, auf den Bereich [0..255] reduziert und in Form von Graustufen auf dem Display angezeigt. Nichts hindert jedoch daran, eine Palette zum Färben des Bildes zu verwenden.

Um das Bild auf dem Display anzuzeigen, verwende ich das in diesen Controller integrierte FSMC-Modul im 8-Bit-Datenbusmodus.

Das vollständige Programm kann hier heruntergeladen werden .

Video der Arbeit (leider habe ich mit einer alten Kamera in der entsprechenden Qualität aufgenommen - ich habe jetzt keine Videokamera dabei).

PS Übrigens können Sie die Wärmebildkamera Flir One Gen 2 direkt über USB an die Debug-Karte STM32F407Discovery anschließen. Die Verbindung ist jedoch instabil - die Wärmebildkamera geht häufig verloren.

Das Programm für eine solche Verbindung ist hier . Vielleicht wird jemand verstehen, was es ist und wie man die Verbindung stabil macht.

Auch dieses Lepton 3-Modul lässt sich einfach und einfach mit dem Raspberry Pi verbinden.

In diesem Fall musste ich das Programm aus dem Repository ändern, damit meine Version mit Lepton 3 funktioniert.

Nachtsichtgerät basierend auf dem Wärmebildmodul Flir Lepton 3

More articles: