通過 TCP 發送帶有 mlx90640 的熱圖像

Question

我的程序有問題我正在嘗試發送從 MLX90640 收集的圖像，這要歸功於 Raspberry 在遠程 PC 中處理它們。 我使用 Raspberry 4 作為客戶端，數據被路由到 PC。 我正在使用套接字啟動要接收圖像和熱圖像的服務器。 對於連接到相機的圖像，我處理了它，我的問題是傳輸熱圖像。 我目前正在使用與手機共享的 wifi 連接進行測試。如有必要，我將發布服務器代碼。 但是我有這個錯誤消息我嘗試了很多解決方案但我沒有找到它。 實際上，Raspberry 是客戶端，PC 是服務器。 因此，我從樹莓中收集數據，然后將其傳輸到 PC 進行處理。 我想檢測面部的溫度，為此連接到 Raspberry 的 MLX90640 必須發送熱數據。 知道它收集了 768 個值，所以我希望將這些值傳輸或將最大值返回給 PC。 有人能幫我嗎

import cv2
import io
import socket
import struct
import time
import pickle
import zlib
import adafruit_mlx90640
import board
import busio
import numpy as np

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('192.168.43.134', 8485))
connection = client_socket.makefile('wb')
i2c = busio.I2C(board.SCL, board.SDA, frequency=800000)
mlx = adafruit_mlx90640.MLX90640(i2c)
print("MLX addr detected on I2C")
print([hex(i) for i in mlx.serial_number])
mlx.refresh_rate = adafruit_mlx90640.RefreshRate.REFRESH_4_HZ
frame1 = np.zeros((24*32,))
#max_t=0
#moy = 0
#cam = cv2.VideoCapture(0)

#mlx.set(3, 32);
#mlx.set(4, 24);

img_counter = 0

encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]

while True:
    frame = mlx.getFrame(frame1)
    result, frame = cv2.imencode('.jpg', frame, encode_param)
#    data = zlib.compress(pickle.dumps(frame, 0))
    data = pickle.dumps(frame, 0)
    size = len(data)

    print("{}: {}".format(img_counter, size))
    client_socket.sendall(struct.pack(">L", size) + data)
    img_counter += 1

```Traceback (most recent call last): File "client1.py", line 37, in <module> result, frame = cv2.imencode('.jpg', frame, encode_param) cv2.error: OpenCV(4.1.1) /home/pi/opencv/modules/imgcodecs/src/grfmt_base.cpp:145: error: (-10:Unknown error code -10) Raw image encoder error: Empty JPEG image (DNL not supported) in function 'throwOnEror'

Answer 1

您設法在 Raspberry pi 上獲得熱量嗎？ 我做了類似的方法，但我沒有使用熱像儀。 如果您的問題無法將圖像從樹莓派傳輸到您的計算機

樹莓派上的服務器代碼

#!/usr/bin/env python3
import os
import datetime
import numpy as np
import cv2
import sys
import socket
import select
import queue
import pickle
import struct
import time
from threading import Thread

class WebcamVideoStream:
    def __init__(self, src=0):
        self.stream = cv2.VideoCapture(src)
        cv2.VideoWriter_fourcc('M','J','P','G')
        self.stream .set(cv2.CAP_PROP_BUFFERSIZE,1)
        self.stream .set(5, 60)
        self.stream .set(3,640)
        self.stream .set(4,480)
        (self.grabbed, self.frame) = self.stream.read()
        self.stopped = False

    def start(self):
        Thread(target=self.update, args=()).start()
        return self
    def update(self):
        while True:
            if self.stopped:
                return
            (self.grabbed, self.frame) = self.stream.read()
            time.sleep(0.1)
    def read(self):
        img= cv2.cvtColor(self.frame , cv2.COLOR_BGR2GRAY)
        data = pickle.dumps(img)
        return data
    def stop(self):
        self.stopped = True


def commandParser(cmd, stream):
    reply = ""
    if(cmd == "getimage"):
        reply = stream.read()
        time.sleep(0.1)
    else:
        reply = '/n'.encode()
    return(reply)

if __name__ == '__main__':
    camera_idx = 0
    for i in range(3):
        stream = cv2.VideoCapture(i)
        test,frame = stream.read()
        stream.release()
        if test == True:
            camera_idx = i
            break
    #stream = cv2.VideoCapture(camera_idx)
    vs = WebcamVideoStream(src=camera_idx).start()

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    port = 8080
    server.bind(('192.168.128.14', port))
    server.listen(5)
    inputs = [server]
    outputs = []
    message_queues = {}
    cmd =""
    while inputs:
        readable, writable, exceptional = select.select(inputs, outputs, inputs, 1)
        for s in readable:
            if s is server:
                connection, client_address = s.accept()
                inputs.append(connection)
                message_queues[connection] = queue.Queue(1024)
            else:
                data = s.recv(4096)
                if data:
                    cmd = data.decode()
                    message_queues[s].put(commandParser(data.decode(), vs))
                    if s not in outputs:
                                    outputs.append(s)
                else:
                    if s in outputs:
                        outputs.remove(s)
                    inputs.remove(s)
                    s.close()
                    del message_queues[s]

        for s in writable:
            try:
                next_msg = message_queues[s].get_nowait()
            except queue.Empty:
                outputs.remove(s)

            else:
                if(cmd == "getimage"):
                    size = len(next_msg)
                    s.sendall(struct.pack(">L", size) + next_msg)
                else:
                    s.send("ABCDEFGHIJKLMNONOOO".encode())


        for s in exceptional:
            print ('handling exceptional condition for', s.getpeername())
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
            del message_queues[s]
    vs.stop() 

PC端的客戶端代碼

#!/usr/bin/env python3
import os
import datetime
import numpy as np
import cv2
import socket
import socket
import sys
import pickle
import struct ## new
import zlib
import time

server_address = ('192.168.128.14', 8080)



s =  socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#print ('connecting to %s port %s' % server_address)
s.connect(server_address)

cv2.namedWindow('Streaming')
payload_size = struct.calcsize(">L")

while True:
    s.send("getimage".encode())

    data = b""
    while len(data) < payload_size:
        data += s.recv(4096)

    packed_msg_size = data[:payload_size]
    data = data[payload_size:]
    msg_size = struct.unpack(">L", packed_msg_size)[0]
    while len(data) < msg_size:
        data += s.recv(4096)
    frame_data = data[:msg_size]
    data = data[msg_size:]
    frame=pickle.loads(frame_data, fix_imports=True, encoding="bytes")
    cv2.imshow('Streaming',frame)
    cv2.waitKey(1)
    #cv2.imwrite("test.tiff", frame)
s.close()