Eduardo_Scripniciuc/st-ten-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hikrobot sc finally got the image

Browse Source
This commit is contained in:
gg 2025-01-22 16:25:39 +01:00
parent 404d9b7a28
commit 15decde342
2 changed files with 224 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
src/components/hikrobot_dll.py
View File

@ -1,4 +1,5 @@
import ctypes import ctypes
import json
import socket import socket
import struct import struct
from ctypes import * from ctypes import *
@ -9,92 +10,104 @@ MV_VS_OK=0x00000000
CHUNK_MASK_IMAGE_PORT=60005536 CHUNK_MASK_IMAGE_PORT=60005536
CHUNK_RESULT_PORT=60005537 CHUNK_RESULT_PORT=60005537
ImageExLen = 4096
MV_VS_GVSP_PIX_MONO = 0x01000000
MV_VS_GVSP_PIX_COLOR = 0x02000000
MV_VS_GVSP_PIX_CUSTOM = 0x80000000
MV_VS_GVSP_PIX_COLOR_MASK = 0xFF000000
MV_VS_GVSP_PIX_EFFECTIVE_PIXEL_SIZE_MASK = 0x00FF0000
MV_VS_GVSP_PIX_EFFECTIVE_PIXEL_SIZE_SHIFT = 16
MV_VS_GVSP_PIX_ID_MASK = 0x0000FFFF
MV_VS_GVSP_PIX_COUNT = 0x46
# Define the macro
def MV_VS_PIXEL_BIT_COUNT(n):
return (n) << 16
mv_lib = ctypes.windll.LoadLibrary("src/test/hikrobot_sc/bin/MvVisionSensorControl.dll") mv_lib = ctypes.windll.LoadLibrary("src/test/hikrobot_sc/bin/MvVisionSensorControl.dll")
# define structures # define structures
from ctypes import * from ctypes import *
class MvVSGvspPixelType(c_int): class MvVSGvspPixelType(ctypes.c_uint32): # Use c_uint32 for compatibility
MVVS_PixelType_Undefined = 0xFFFFFFFF MVVS_PixelType_Undefined = 0xFFFFFFFF
MVVS_PixelType_Mono1p = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(1) | 0x0037)
MVVS_PixelType_Mono1p = (0x0037) MVVS_PixelType_Mono2p = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(2) | 0x0038)
MVVS_PixelType_Mono2p = (0x0038) MVVS_PixelType_Mono4p = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(4) | 0x0039)
MVVS_PixelType_Mono4p = (0x0039) MVVS_PixelType_Mono8 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x0001)
MVVS_PixelType_Mono8 = (0x0001) MVVS_PixelType_Mono8_Signed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x0002)
MVVS_PixelType_Mono8_Signed = (0x0002) MVVS_PixelType_Mono10 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0003)
MVVS_PixelType_Mono10 = (0x0003) MVVS_PixelType_Mono10_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0004)
MVVS_PixelType_Mono10_Packed = (0x0004) MVVS_PixelType_Mono12 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0005)
MVVS_PixelType_Mono12 = (0x0005) MVVS_PixelType_Mono12_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0006)
MVVS_PixelType_Mono12_Packed = (0x0006) MVVS_PixelType_Mono14 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0025)
MVVS_PixelType_Mono14 = (0x0025) MVVS_PixelType_Mono16 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0007)
MVVS_PixelType_Mono16 = (0x0007) MVVS_PixelType_BayerGR8 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x0008)
MVVS_PixelType_BayerRG8 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x0009)
MVVS_PixelType_BayerGR8 = (0x0008) MVVS_PixelType_BayerGB8 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x000A)
MVVS_PixelType_BayerRG8 = (0x0009) MVVS_PixelType_BayerBG8 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(8) | 0x000B)
MVVS_PixelType_BayerGB8 = (0x000A) MVVS_PixelType_BayerGR10 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x000C)
MVVS_PixelType_BayerBG8 = (0x000B) MVVS_PixelType_BayerRG10 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x000D)
MVVS_PixelType_BayerGR10 = (0x000C) MVVS_PixelType_BayerGB10 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x000E)
MVVS_PixelType_BayerRG10 = (0x000D) MVVS_PixelType_BayerBG10 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x000F)
MVVS_PixelType_BayerGB10 = (0x000E) MVVS_PixelType_BayerGR12 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0010)
MVVS_PixelType_BayerBG10 = (0x000F) MVVS_PixelType_BayerRG12 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0011)
MVVS_PixelType_BayerGR12 = (0x0010) MVVS_PixelType_BayerGB12 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0012)
MVVS_PixelType_BayerRG12 = (0x0011) MVVS_PixelType_BayerBG12 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0013)
MVVS_PixelType_BayerGB12 = (0x0012) MVVS_PixelType_BayerGR10_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0026)
MVVS_PixelType_BayerBG12 = (0x0013) MVVS_PixelType_BayerRG10_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0027)
MVVS_PixelType_BayerGR10_Packed = (0x0026) MVVS_PixelType_BayerGB10_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0028)
MVVS_PixelType_BayerRG10_Packed = (0x0027) MVVS_PixelType_BayerBG10_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x0029)
MVVS_PixelType_BayerGB10_Packed = (0x0028) MVVS_PixelType_BayerGR12_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x002A)
MVVS_PixelType_BayerBG10_Packed = (0x0029) MVVS_PixelType_BayerRG12_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x002B)
MVVS_PixelType_BayerGR12_Packed = (0x002A) MVVS_PixelType_BayerGB12_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x002C)
MVVS_PixelType_BayerRG12_Packed = (0x002B) MVVS_PixelType_BayerBG12_Packed = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(12) | 0x002D)
MVVS_PixelType_BayerGB12_Packed = (0x002C) MVVS_PixelType_BayerGR16 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x002E)
MVVS_PixelType_BayerBG12_Packed = (0x002D) MVVS_PixelType_BayerRG16 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x002F)
MVVS_PixelType_BayerGR16 = (0x002E) MVVS_PixelType_BayerGB16 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0030)
MVVS_PixelType_BayerRG16 = (0x002F) MVVS_PixelType_BayerBG16 = (MV_VS_GVSP_PIX_MONO | MV_VS_PIXEL_BIT_COUNT(16) | 0x0031)
MVVS_PixelType_BayerGB16 = (0x0030) MVVS_PixelType_RGB8_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x0014)
MVVS_PixelType_BayerBG16 = (0x0031) MVVS_PixelType_BGR8_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x0015)
MVVS_PixelType_RGBA8_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(32) | 0x0016)
MVVS_PixelType_RGB8_Packed = (0x0014) MVVS_PixelType_BGRA8_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(32) | 0x0017)
MVVS_PixelType_BGR8_Packed = (0x0015) MVVS_PixelType_RGB10_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0018)
MVVS_PixelType_RGBA8_Packed = (0x0016) MVVS_PixelType_BGR10_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0019)
MVVS_PixelType_BGRA8_Packed = (0x0017) MVVS_PixelType_RGB12_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x001A)
MVVS_PixelType_RGB10_Packed = (0x0018) MVVS_PixelType_BGR12_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x001B)
MVVS_PixelType_BGR10_Packed = (0x0019) MVVS_PixelType_RGB16_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0033)
MVVS_PixelType_RGB12_Packed = (0x001A) MVVS_PixelType_BGR16_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x004B)
MVVS_PixelType_BGR12_Packed = (0x001B) MVVS_PixelType_RGBA16_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(64) | 0x0064)
MVVS_PixelType_RGB16_Packed = (0x0033) MVVS_PixelType_BGRA16_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(64) | 0x0051)
MVVS_PixelType_BGR16_Packed = (0x004B) MVVS_PixelType_RGB10V1_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(32) | 0x001C)
MVVS_PixelType_RGBA16_Packed = (0x0064) MVVS_PixelType_RGB10V2_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(32) | 0x001D)
MVVS_PixelType_BGRA16_Packed = (0x0051) MVVS_PixelType_RGB12V1_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(36) | 0x0034)
MVVS_PixelType_RGB10V1_Packed = (0x001C) MVVS_PixelType_RGB565_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0035)
MVVS_PixelType_RGB10V2_Packed = (0x001D) MVVS_PixelType_BGR565_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0036)
MVVS_PixelType_RGB12V1_Packed = (0X0034) MVVS_PixelType_YUV411_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(12) | 0x001E)
MVVS_PixelType_RGB565_Packed = (0x0035) MVVS_PixelType_YUV422_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x001F)
MVVS_PixelType_BGR565_Packed = (0X0036) MVVS_PixelType_YUV422_YUYV_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0032)
MVVS_PixelType_YUV444_Packed = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x0020)
MVVS_PixelType_YUV411_Packed = (0x001E) MVVS_PixelType_YCBCR8_CBYCR = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x003A)
MVVS_PixelType_YUV422_Packed = (0x001F) MVVS_PixelType_YCBCR422_8 = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x003B)
MVVS_PixelType_YUV422_YUYV_Packed = (0x0032) MVVS_PixelType_YCBCR422_8_CBYCRY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0043)
MVVS_PixelType_YUV444_Packed = (0x0020) MVVS_PixelType_YCBCR411_8_CBYYCRYY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(12) | 0x003C)
MVVS_PixelType_YCBCR8_CBYCR = (0x003A) MVVS_PixelType_YCBCR601_8_CBYCR = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x003D)
MVVS_PixelType_YCBCR422_8 = (0x003B) MVVS_PixelType_YCBCR601_422_8 = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x003E)
MVVS_PixelType_YCBCR422_8_CBYCRY = (0x0043) MVVS_PixelType_YCBCR601_422_8_CBYCRY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0044)
MVVS_PixelType_YCBCR411_8_CBYYCRYY = (0x003C) MVVS_PixelType_YCBCR601_411_8_CBYYCRYY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(12) | 0x003F)
MVVS_PixelType_YCBCR601_8_CBYCR = (0x003D) MVVS_PixelType_YCBCR709_8_CBYCR = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x0040)
MVVS_PixelType_YCBCR601_422_8 = (0x003E) MVVS_PixelType_YCBCR709_422_8 = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0041)
MVVS_PixelType_YCBCR601_422_8_CBYCRY = (0x0044) MVVS_PixelType_YCBCR709_422_8_CBYCRY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(16) | 0x0045)
MVVS_PixelType_YCBCR601_411_8_CBYYCRYY = (0x003F) MVVS_PixelType_YCBCR709_411_8_CBYYCRYY = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(12) | 0x0042)
MVVS_PixelType_YCBCR709_8_CBYCR = (0x0040) MVVS_PixelType_RGB8_Planar = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(24) | 0x0021)
MVVS_PixelType_YCBCR709_422_8 = (0x0041) MVVS_PixelType_RGB10_Planar = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0022)
MVVS_PixelType_YCBCR709_422_8_CBYCRY = (0x0045) MVVS_PixelType_RGB12_Planar = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0023)
MVVS_PixelType_YCBCR709_411_8_CBYYCRYY = (0x0042) MVVS_PixelType_RGB16_Planar = (MV_VS_GVSP_PIX_COLOR | MV_VS_PIXEL_BIT_COUNT(48) | 0x0024)
MVVS_PixelType_Jpeg = (MV_VS_GVSP_PIX_CUSTOM | MV_VS_PIXEL_BIT_COUNT(24) | 0x0001)
MVVS_PixelType_RGB8_Planar = (0x0021)
MVVS_PixelType_RGB10_Planar = (0x0022)
MVVS_PixelType_RGB12_Planar = (0x0023)
MVVS_PixelType_RGB16_Planar = (0x0024)
MVVS_PixelType_Jpeg = (0x0001)
class MV_VS_DATA(Structure): class MV_VS_DATA(Structure):
_fields_ = [ _fields_ = [
@ -160,10 +173,21 @@ class PROCESS_MEMORY_COUNTERS(ctypes.Structure):
] ]
class MV_VS_JPG_PARAM(ctypes.Structure):
_fields_ = [
("pBufInput", ctypes.POINTER(ctypes.c_ubyte)),
("nBufInputLen", ctypes.c_uint),
("nWidth", ctypes.c_uint),
("nHeight", ctypes.c_uint),
("nJpgQuality", ctypes.c_uint),
("pBufOutput", ctypes.POINTER(ctypes.c_ubyte)),
("nBufOutputLen", ctypes.c_uint),
]
# PPROCESS_MEMORY_COUNTERS is simply a pointer to the struct # PPROCESS_MEMORY_COUNTERS is simply a pointer to the struct
PPROCESS_MEMORY_COUNTERS = ctypes.POINTER(PROCESS_MEMORY_COUNTERS) PPROCESS_MEMORY_COUNTERS = ctypes.POINTER(PROCESS_MEMORY_COUNTERS)
# Define function signatures # Define function signatures
mv_lib.MV_VS_GetResultData.argtypes = [c_void_p, POINTER(MV_VS_DATA), c_int] mv_lib.MV_VS_GetResultData.argtypes = [c_void_p, POINTER(MV_VS_DATA), c_int]
@ -192,11 +216,11 @@ mv_lib.MV_VS_StartRun.restype = c_int
def MV_VS_GetFrame(handle): def MV_VS_GetFrame(handle):
nRet = MV_VS_OK
while True:
stFrameData = MV_VS_DATA() stFrameData = MV_VS_DATA()
nRet = mv_lib.MV_VS_GetResultData(handle, byref(stFrameData), 1000)
nRet = mv_lib.MV_VS_GetResultData(handle, byref(stFrameData), 2000)
if nRet == MV_VS_OK: if nRet == MV_VS_OK:
# Print frame information # Print frame information
print( print(
@ -228,13 +252,20 @@ def MV_VS_GetFrame(handle):
if chunkLength.value <= 0 or chunkLength.value > stFrameData.nChunkDataLen - 8 - currentDataTag: if chunkLength.value <= 0 or chunkLength.value > stFrameData.nChunkDataLen - 8 - currentDataTag:
break break
if chunkID == CHUNK_RESULT_PORT: # Result data in JSON format if chunkID.value == CHUNK_RESULT_PORT: # Result data in JSON format
chResultInfo = ctypes.cast( chRawInfo = ctypes.cast(stFrameData.pChunkData, ctypes.POINTER(ctypes.c_char))
stFrameData.pChunkData + (stFrameData.nChunkDataLen - 8 - chunkLength - currentDataTag), chRawInfo = ctypes.cast(ctypes.addressof(
chRawInfo.contents) + stFrameData.nChunkDataLen - 8 - chunkLength.value - currentDataTag,
ctypes.POINTER(ctypes.c_char)) ctypes.POINTER(ctypes.c_char))
print(f"chResultInfo [{chResultInfo.value.decode()}] end")
elif chunkID == CHUNK_MASK_IMAGE_PORT: # Mask image data chResultInfo = ctypes.string_at(chRawInfo, chunkLength.value)
chResultInfo = json.loads(chResultInfo.decode())
if chResultInfo:
print(f"chResultInfo OK")
elif chunkID.value == CHUNK_MASK_IMAGE_PORT: # Mask image data
maskModID = ctypes.c_uint32() maskModID = ctypes.c_uint32()
maskModFormat = ctypes.c_uint32() maskModFormat = ctypes.c_uint32()
maskModWidth = ctypes.c_uint32() maskModWidth = ctypes.c_uint32()
@ -254,7 +285,7 @@ def MV_VS_GetFrame(handle):
ctypes.memmove(ctypes.byref(maskModHeight), source_address_height, 4) ctypes.memmove(ctypes.byref(maskModHeight), source_address_height, 4)
print( print(
f"Mask ModID[{maskModID}], ModFormat[{maskModFormat}], ModWidth[{maskModWidth}], ModHeight[{maskModHeight}], ") f"Mask ModID[{maskModID.value}], ModFormat[{maskModFormat.value}], ModWidth[{maskModWidth.value}], ModHeight[{maskModHeight.value}], ")
try: try:
chMaskModImageData = ctypes.cast(ctypes.create_string_buffer(chunkLength.value - 16 + 1), chMaskModImageData = ctypes.cast(ctypes.create_string_buffer(chunkLength.value - 16 + 1),
@ -271,19 +302,22 @@ def MV_VS_GetFrame(handle):
print(f"Error allocating or copying memory: {e}") print(f"Error allocating or copying memory: {e}")
currentDataTag = currentDataTag + 8 + chunkLength.value currentDataTag = currentDataTag + 8 + chunkLength.value
# end process chunk data
else: m_stJpgParam = MV_VS_JPG_PARAM()
print(f"Get frame buffer fail! nRet [0x{nRet:x}]") m_stJpgParam.pBufInput = ctypes.cast(stFrameData.pImage,ctypes.POINTER(ctypes.c_ubyte))
m_stJpgParam.nBufInputLen = stFrameData.nImageLen
jpegContents = ctypes.string_at(m_stJpgParam.pBufInput, m_stJpgParam.nBufInputLen)
with open("tmp/test.jpg", "wb") as f:
f.write(jpegContents)
# Release frame buffer # Release frame buffer
nRet = mv_lib.MV_VS_ReleaseResultData(handle, ctypes.byref(stFrameData)) nRet = mv_lib.MV_VS_ReleaseResultData(handle, ctypes.byref(stFrameData))
if nRet != MV_VS_OK: if nRet != MV_VS_OK:
print(f"Release frame buffer fail! nRet [0x{nRet:x}]") print(f"Release frame buffer fail! nRet [0x{nRet:x}]")
else: else:
print(f"MV_VS_GetResultData fail! nRet [0x{nRet&0xFFFFFFFF:x}]") print(f"Release frame buffer OK")
nRet = mv_lib.MV_VS_ReleaseResultData(handle, byref(stFrameData))
if nRet != MV_VS_OK:
print(f"Release frame buffer fail! nRet [0x{nRet&0xFFFFFFFF:x}]")
else: else:
print("Release frame buffer OK") print(f"MV_VS_GetResultData fail! nRet [0x{nRet&0xFFFFFFFF:x}]")

34
src/test/hikrobot_sc/test_hikrobot_sc.py
View File

@ -49,20 +49,24 @@ def main():
pHandle1 = c_void_p() pHandle1 = c_void_p()
pHandle2 = c_void_p() pHandle2 = c_void_p()
nRet1 = mv_lib.MV_VS_CreateHandle(byref(pHandle1), MV_VS_DEVICE_INFO_1) nRet1 = mv_lib.MV_VS_CreateHandle(byref(pHandle1), MV_VS_DEVICE_INFO_1)
nRet2 = mv_lib.MV_VS_CreateHandle(byref(pHandle2), MV_VS_DEVICE_INFO_2) nRet2=0
#nRet2 = mv_lib.MV_VS_CreateHandle(byref(pHandle2), MV_VS_DEVICE_INFO_2)
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK: if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"Create Handle failed! [{nRet1:#x} {nRet2:#x}]") print(f"Create Handle failed! [{nRet1:#x} {nRet2:#x}]")
return return
time.sleep(0.1)
nRet1 = mv_lib.MV_VS_Login(pHandle1, b"Admin", b"Abc1234") nRet1 = mv_lib.MV_VS_Login(pHandle1, b"Admin", b"Abc1234")
nRet2 = mv_lib.MV_VS_Login(pHandle2, b"Admin", b"Abc1234") time.sleep(0.1)
#nRet2 = mv_lib.MV_VS_Login(pHandle2, b"Admin", b"Abc1234")
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK: if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"Login failed! [{nRet1:#x} {nRet2:#x}]") print(f"Login failed! [{nRet1&0xFFFFFFFF:#x} {nRet2&0xFFFFFFFF:#x}]")
return return
else: else:
print("Login OK") print("Login OK")
nRet1 = mv_lib.MV_VS_SetBoolValue(pHandle1, b"CommandImageMode", 0) nRet1 = mv_lib.MV_VS_SetBoolValue(pHandle1, b"CommandImageMode", 0)
nRet2 = mv_lib.MV_VS_SetBoolValue(pHandle2, b"CommandImageMode", 0) #nRet2 = mv_lib.MV_VS_SetBoolValue(pHandle2, b"CommandImageMode", 0)
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK: if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"CommandImageMode failed! [{nRet1&0xFFFFFFFF:#x} {nRet2&0xFFFFFFFF:#x}]") print(f"CommandImageMode failed! [{nRet1&0xFFFFFFFF:#x} {nRet2&0xFFFFFFFF:#x}]")
return return
@ -70,7 +74,7 @@ def main():
print("CommandImageMode OK") print("CommandImageMode OK")
nRet1 = mv_lib.MV_VS_SetEnumValue(pHandle1, b"AcquisitionMode", 0) nRet1 = mv_lib.MV_VS_SetEnumValue(pHandle1, b"AcquisitionMode", 0)
nRet2 = mv_lib.MV_VS_SetEnumValue(pHandle2, b"AcquisitionMode", 0) #nRet2 = mv_lib.MV_VS_SetEnumValue(pHandle2, b"AcquisitionMode", 0)
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK: if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"AcquisitionMode failed! [{nRet1&0xFFFFFFFF:#x} {nRet2&0xFFFFFFFF:#x}]") print(f"AcquisitionMode failed! [{nRet1&0xFFFFFFFF:#x} {nRet2&0xFFFFFFFF:#x}]")
return return
@ -93,22 +97,32 @@ def main():
# Create the thread # Create the thread
thread = threading.Thread(target=MV_VS_GetFrame, args=(pHandle1,)) thread = threading.Thread(target=MV_VS_GetFrame, args=(pHandle1,))
thread2 = threading.Thread(target=MV_VS_GetFrame, args=(pHandle2,))
# Start the thread # Start the thread
thread.start() thread.start()
#thread2.start()
#Start the camera test
nRet1 = mv_lib.MV_VS_StartRun(pHandle1)
#nRet2 = mv_lib.MV_VS_StartRun(pHandle2)
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"Start run failed! [{nRet1 & 0xFFFFFFFF:#x} {nRet2 & 0xFFFFFFFF:#x}]")
while True: while True:
print("main loop cycle") print("main loop cycle")
nRet1 = mv_lib.MV_VS_StartRun(pHandle1)
nRet2 = mv_lib.MV_VS_StartRun(pHandle2) #Trigger acquisition & test execution
nRet1 = mv_lib.MV_VS_SetCommandValue(pHandle1, "AcquisitionStart")
#nRet2 = mv_lib.MV_VS_SetCommandValue(pHandle2, "AcquisitionStart")
if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK: if nRet1 != MV_VS_OK or nRet2 != MV_VS_OK:
print(f"Start run failed! [{nRet1 & 0xFFFFFFFF:#x} {nRet2 & 0xFFFFFFFF:#x}]") print(f"AcquisitionStart failed! [{nRet1 & 0xFFFFFFFF:#x} {nRet2 & 0xFFFFFFFF:#x}]")
return
else: else:
print("Start run OK") print("AcquisitionStart OK")
time.sleep(1) time.sleep(1)
return 0 return 0
if __name__ == "__main__": if __name__ == "__main__":
main() main()