通过TCP使用mlx90640发送热图像

Question

我的程序有问题，我正试图发送我从MLX90640收集的图像，感谢树莓在远程PC中处理它们。 我使用Raspberry 4作为客户端，数据被路由到PC。我使用套接字启动服务器，接收图像和热图像。对于连接到相机的图像，我负责处理，我的问题是传输热图像。我目前正在使用与手机共享的wifi连接进行测试。如有必要，我会发布服务器代码。但我有这个错误消息，我尝试了很多解决方案，但我没有找到它。事实上，树莓是客户端，PC是服务器。因此，我从树莓中收集数据，将其传输到PC机进行处理。我想检测面部温度，因此连接到覆盆子的MLX90640必须发送热量数据。知道它收集768个值，所以我想要这些值​​发送或返回到电脑的最大值。有人能帮我吗

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能得到热量吗？我做了一个类似的方法，但我没有使用热相机。如果您的问题是无法将图像从raspberry pi传输到您的计算机

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()