608 lines
30 KiB
Plaintext
608 lines
30 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "intro",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Camera Status and Availability Testing\n",
|
|
"\n",
|
|
"This notebook tests various methods to check camera status and availability before attempting to capture images.\n",
|
|
"\n",
|
|
"## Key Functions to Test:\n",
|
|
"- `CameraIsOpened()` - Check if camera is already opened by another process\n",
|
|
"- `CameraInit()` - Try to initialize and catch specific error codes\n",
|
|
"- `CameraGetImageBuffer()` - Test actual image capture with timeout\n",
|
|
"- Error code analysis for different failure scenarios"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 26,
|
|
"id": "imports",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Libraries imported successfully!\n",
|
|
"Platform: Linux\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Import required libraries\n",
|
|
"import os\n",
|
|
"import sys\n",
|
|
"import time\n",
|
|
"import numpy as np\n",
|
|
"import cv2\n",
|
|
"import platform\n",
|
|
"from datetime import datetime\n",
|
|
"\n",
|
|
"# Add the python demo directory to path to import mvsdk\n",
|
|
"sys.path.append('../python demo')\n",
|
|
"import mvsdk\n",
|
|
"\n",
|
|
"print(\"Libraries imported successfully!\")\n",
|
|
"print(f\"Platform: {platform.system()}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 27,
|
|
"id": "error-codes",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Relevant Camera Status Error Codes:\n",
|
|
"========================================\n",
|
|
"CAMERA_STATUS_SUCCESS: 0\n",
|
|
"CAMERA_STATUS_DEVICE_IS_OPENED: -18\n",
|
|
"CAMERA_STATUS_DEVICE_IS_CLOSED: -19\n",
|
|
"CAMERA_STATUS_ACCESS_DENY: -45\n",
|
|
"CAMERA_STATUS_DEVICE_LOST: -38\n",
|
|
"CAMERA_STATUS_TIME_OUT: -12\n",
|
|
"CAMERA_STATUS_BUSY: -28\n",
|
|
"CAMERA_STATUS_NO_DEVICE_FOUND: -16\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Let's examine the relevant error codes from the SDK\n",
|
|
"print(\"Relevant Camera Status Error Codes:\")\n",
|
|
"print(\"=\" * 40)\n",
|
|
"print(f\"CAMERA_STATUS_SUCCESS: {mvsdk.CAMERA_STATUS_SUCCESS}\")\n",
|
|
"print(f\"CAMERA_STATUS_DEVICE_IS_OPENED: {mvsdk.CAMERA_STATUS_DEVICE_IS_OPENED}\")\n",
|
|
"print(f\"CAMERA_STATUS_DEVICE_IS_CLOSED: {mvsdk.CAMERA_STATUS_DEVICE_IS_CLOSED}\")\n",
|
|
"print(f\"CAMERA_STATUS_ACCESS_DENY: {mvsdk.CAMERA_STATUS_ACCESS_DENY}\")\n",
|
|
"print(f\"CAMERA_STATUS_DEVICE_LOST: {mvsdk.CAMERA_STATUS_DEVICE_LOST}\")\n",
|
|
"print(f\"CAMERA_STATUS_TIME_OUT: {mvsdk.CAMERA_STATUS_TIME_OUT}\")\n",
|
|
"print(f\"CAMERA_STATUS_BUSY: {mvsdk.CAMERA_STATUS_BUSY}\")\n",
|
|
"print(f\"CAMERA_STATUS_NO_DEVICE_FOUND: {mvsdk.CAMERA_STATUS_NO_DEVICE_FOUND}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 28,
|
|
"id": "status-functions",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Camera Availability Check\n",
|
|
"==============================\n",
|
|
"✓ SDK initialized successfully\n",
|
|
"✓ Found 2 camera(s)\n",
|
|
" 0: Blower-Yield-Cam (192.168.1.165-192.168.1.54)\n",
|
|
" 1: Cracker-Cam (192.168.1.167-192.168.1.54)\n",
|
|
"\n",
|
|
"Testing camera 0: Blower-Yield-Cam\n",
|
|
"✓ Camera is available (not opened by another process)\n",
|
|
"✓ Camera initialized successfully\n",
|
|
"✓ Camera closed after testing\n",
|
|
"\n",
|
|
"Testing camera 1: Cracker-Cam\n",
|
|
"✓ Camera is available (not opened by another process)\n",
|
|
"✓ Camera initialized successfully\n",
|
|
"✓ Camera closed after testing\n",
|
|
"\n",
|
|
"Results for 2 cameras:\n",
|
|
" Camera 0: AVAILABLE\n",
|
|
" Camera 1: AVAILABLE\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def check_camera_availability():\n",
|
|
" \"\"\"\n",
|
|
" Comprehensive camera availability check\n",
|
|
" \"\"\"\n",
|
|
" print(\"Camera Availability Check\")\n",
|
|
" print(\"=\" * 30)\n",
|
|
" \n",
|
|
" # Step 1: Initialize SDK\n",
|
|
" try:\n",
|
|
" mvsdk.CameraSdkInit(1)\n",
|
|
" print(\"✓ SDK initialized successfully\")\n",
|
|
" except Exception as e:\n",
|
|
" print(f\"✗ SDK initialization failed: {e}\")\n",
|
|
" return None, \"SDK_INIT_FAILED\"\n",
|
|
" \n",
|
|
" # Step 2: Enumerate cameras\n",
|
|
" try:\n",
|
|
" DevList = mvsdk.CameraEnumerateDevice()\n",
|
|
" nDev = len(DevList)\n",
|
|
" print(f\"✓ Found {nDev} camera(s)\")\n",
|
|
" \n",
|
|
" if nDev < 1:\n",
|
|
" print(\"✗ No cameras detected\")\n",
|
|
" return None, \"NO_CAMERAS\"\n",
|
|
" \n",
|
|
" for i, DevInfo in enumerate(DevList):\n",
|
|
" print(f\" {i}: {DevInfo.GetFriendlyName()} ({DevInfo.GetPortType()})\")\n",
|
|
" \n",
|
|
" except Exception as e:\n",
|
|
" print(f\"✗ Camera enumeration failed: {e}\")\n",
|
|
" return None, \"ENUM_FAILED\"\n",
|
|
" \n",
|
|
" # Step 3: Check all cameras\n",
|
|
" camera_results = []\n",
|
|
" \n",
|
|
" for i, DevInfo in enumerate(DevList):\n",
|
|
" print(f\"\\nTesting camera {i}: {DevInfo.GetFriendlyName()}\")\n",
|
|
" \n",
|
|
" # Check if camera is already opened\n",
|
|
" try:\n",
|
|
" is_opened = mvsdk.CameraIsOpened(DevInfo)\n",
|
|
" if is_opened:\n",
|
|
" print(\"✗ Camera is already opened by another process\")\n",
|
|
" camera_results.append((DevInfo, \"ALREADY_OPENED\"))\n",
|
|
" continue\n",
|
|
" else:\n",
|
|
" print(\"✓ Camera is available (not opened by another process)\")\n",
|
|
" except Exception as e:\n",
|
|
" print(f\"⚠ Could not check if camera is opened: {e}\")\n",
|
|
" \n",
|
|
" # Try to initialize camera\n",
|
|
" try:\n",
|
|
" hCamera = mvsdk.CameraInit(DevInfo, -1, -1)\n",
|
|
" print(\"✓ Camera initialized successfully\")\n",
|
|
" camera_results.append((hCamera, \"AVAILABLE\"))\n",
|
|
" \n",
|
|
" # Close the camera after testing\n",
|
|
" try:\n",
|
|
" mvsdk.CameraUnInit(hCamera)\n",
|
|
" print(\"✓ Camera closed after testing\")\n",
|
|
" except Exception as e:\n",
|
|
" print(f\"⚠ Warning: Could not close camera: {e}\")\n",
|
|
" \n",
|
|
" except mvsdk.CameraException as e:\n",
|
|
" print(f\"✗ Camera initialization failed: {e.error_code} - {e.message}\")\n",
|
|
" \n",
|
|
" # Analyze specific error codes\n",
|
|
" if e.error_code == mvsdk.CAMERA_STATUS_DEVICE_IS_OPENED:\n",
|
|
" camera_results.append((DevInfo, \"DEVICE_OPENED\"))\n",
|
|
" elif e.error_code == mvsdk.CAMERA_STATUS_ACCESS_DENY:\n",
|
|
" camera_results.append((DevInfo, \"ACCESS_DENIED\"))\n",
|
|
" elif e.error_code == mvsdk.CAMERA_STATUS_DEVICE_LOST:\n",
|
|
" camera_results.append((DevInfo, \"DEVICE_LOST\"))\n",
|
|
" else:\n",
|
|
" camera_results.append((DevInfo, f\"INIT_ERROR_{e.error_code}\"))\n",
|
|
" \n",
|
|
" except Exception as e:\n",
|
|
" print(f\"✗ Unexpected error during initialization: {e}\")\n",
|
|
" camera_results.append((DevInfo, \"UNEXPECTED_ERROR\"))\n",
|
|
" \n",
|
|
" return camera_results\n",
|
|
"\n",
|
|
"# Test the function\n",
|
|
"camera_results = check_camera_availability()\n",
|
|
"print(f\"\\nResults for {len(camera_results)} cameras:\")\n",
|
|
"for i, (camera_info, status) in enumerate(camera_results):\n",
|
|
" if hasattr(camera_info, 'GetFriendlyName'):\n",
|
|
" name = camera_info.GetFriendlyName()\n",
|
|
" else:\n",
|
|
" name = f\"Camera {i}\"\n",
|
|
" print(f\" {name}: {status}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 29,
|
|
"id": "test-capture-availability",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"Testing capture readiness for 2 available camera(s):\n",
|
|
"\n",
|
|
"Testing camera 0 capture readiness...\n",
|
|
"\n",
|
|
"Testing Camera Capture Readiness\n",
|
|
"===================================\n",
|
|
"✓ Camera capabilities retrieved\n",
|
|
"✓ Camera type: Color\n",
|
|
"✓ Basic camera configuration set\n",
|
|
"✓ Camera started\n",
|
|
"✓ Frame buffer allocated\n",
|
|
"\n",
|
|
"Testing image capture...\n",
|
|
"✓ Image captured successfully: 1280x1024\n",
|
|
"✓ Image processed and buffer released\n",
|
|
"✓ Cleanup completed\n",
|
|
"Capture Ready for Blower-Yield-Cam: True\n",
|
|
"\n",
|
|
"Testing camera 1 capture readiness...\n",
|
|
"\n",
|
|
"Testing Camera Capture Readiness\n",
|
|
"===================================\n",
|
|
"✓ Camera capabilities retrieved\n",
|
|
"✓ Camera type: Color\n",
|
|
"✓ Basic camera configuration set\n",
|
|
"✓ Camera started\n",
|
|
"✓ Frame buffer allocated\n",
|
|
"\n",
|
|
"Testing image capture...\n",
|
|
"✓ Image captured successfully: 1280x1024\n",
|
|
"✓ Image processed and buffer released\n",
|
|
"✓ Cleanup completed\n",
|
|
"Capture Ready for Cracker-Cam: True\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def test_camera_capture_readiness(hCamera):\n",
|
|
" \"\"\"\n",
|
|
" Test if camera is ready for image capture\n",
|
|
" \"\"\"\n",
|
|
" if not isinstance(hCamera, int):\n",
|
|
" print(\"Camera not properly initialized, skipping capture test\")\n",
|
|
" return False\n",
|
|
" \n",
|
|
" print(\"\\nTesting Camera Capture Readiness\")\n",
|
|
" print(\"=\" * 35)\n",
|
|
" \n",
|
|
" try:\n",
|
|
" # Get camera capabilities\n",
|
|
" cap = mvsdk.CameraGetCapability(hCamera)\n",
|
|
" print(\"✓ Camera capabilities retrieved\")\n",
|
|
" \n",
|
|
" # Check camera type\n",
|
|
" monoCamera = (cap.sIspCapacity.bMonoSensor != 0)\n",
|
|
" print(f\"✓ Camera type: {'Monochrome' if monoCamera else 'Color'}\")\n",
|
|
" \n",
|
|
" # Set basic configuration\n",
|
|
" if monoCamera:\n",
|
|
" mvsdk.CameraSetIspOutFormat(hCamera, mvsdk.CAMERA_MEDIA_TYPE_MONO8)\n",
|
|
" else:\n",
|
|
" mvsdk.CameraSetIspOutFormat(hCamera, mvsdk.CAMERA_MEDIA_TYPE_BGR8)\n",
|
|
" \n",
|
|
" mvsdk.CameraSetTriggerMode(hCamera, 0) # Continuous mode\n",
|
|
" mvsdk.CameraSetAeState(hCamera, 0) # Manual exposure\n",
|
|
" mvsdk.CameraSetExposureTime(hCamera, 5000) # 5ms exposure\n",
|
|
" print(\"✓ Basic camera configuration set\")\n",
|
|
" \n",
|
|
" # Start camera\n",
|
|
" mvsdk.CameraPlay(hCamera)\n",
|
|
" print(\"✓ Camera started\")\n",
|
|
" \n",
|
|
" # Allocate buffer\n",
|
|
" FrameBufferSize = cap.sResolutionRange.iWidthMax * cap.sResolutionRange.iHeightMax * (1 if monoCamera else 3)\n",
|
|
" pFrameBuffer = mvsdk.CameraAlignMalloc(FrameBufferSize, 16)\n",
|
|
" print(\"✓ Frame buffer allocated\")\n",
|
|
" \n",
|
|
" # Test image capture with short timeout\n",
|
|
" print(\"\\nTesting image capture...\")\n",
|
|
" try:\n",
|
|
" pRawData, FrameHead = mvsdk.CameraGetImageBuffer(hCamera, 1000) # 1 second timeout\n",
|
|
" print(f\"✓ Image captured successfully: {FrameHead.iWidth}x{FrameHead.iHeight}\")\n",
|
|
" \n",
|
|
" # Process and release\n",
|
|
" mvsdk.CameraImageProcess(hCamera, pRawData, pFrameBuffer, FrameHead)\n",
|
|
" mvsdk.CameraReleaseImageBuffer(hCamera, pRawData)\n",
|
|
" print(\"✓ Image processed and buffer released\")\n",
|
|
" \n",
|
|
" capture_success = True\n",
|
|
" \n",
|
|
" except mvsdk.CameraException as e:\n",
|
|
" print(f\"✗ Image capture failed: {e.error_code} - {e.message}\")\n",
|
|
" \n",
|
|
" if e.error_code == mvsdk.CAMERA_STATUS_TIME_OUT:\n",
|
|
" print(\" → Camera timeout - may be busy or not streaming\")\n",
|
|
" elif e.error_code == mvsdk.CAMERA_STATUS_DEVICE_LOST:\n",
|
|
" print(\" → Device lost - camera disconnected\")\n",
|
|
" elif e.error_code == mvsdk.CAMERA_STATUS_BUSY:\n",
|
|
" print(\" → Camera busy - may be used by another process\")\n",
|
|
" \n",
|
|
" capture_success = False\n",
|
|
" \n",
|
|
" # Cleanup\n",
|
|
" mvsdk.CameraAlignFree(pFrameBuffer)\n",
|
|
" print(\"✓ Cleanup completed\")\n",
|
|
" \n",
|
|
" return capture_success\n",
|
|
" \n",
|
|
" except Exception as e:\n",
|
|
" print(f\"✗ Capture readiness test failed: {e}\")\n",
|
|
" return False\n",
|
|
"\n",
|
|
"# Test capture readiness for available cameras\n",
|
|
"available_cameras = [(cam, stat) for cam, stat in camera_results if stat == \"AVAILABLE\"]\n",
|
|
"\n",
|
|
"if available_cameras:\n",
|
|
" print(f\"\\nTesting capture readiness for {len(available_cameras)} available camera(s):\")\n",
|
|
" for i, (camera_handle, status) in enumerate(available_cameras):\n",
|
|
" if hasattr(camera_handle, 'GetFriendlyName'):\n",
|
|
" # This shouldn't happen for AVAILABLE cameras, but just in case\n",
|
|
" print(f\"\\nCamera {i}: Invalid handle\")\n",
|
|
" continue\n",
|
|
" \n",
|
|
" print(f\"\\nTesting camera {i} capture readiness...\")\n",
|
|
" # Re-initialize the camera for testing since we closed it earlier\n",
|
|
" try:\n",
|
|
" # Find the camera info from the original results\n",
|
|
" DevList = mvsdk.CameraEnumerateDevice()\n",
|
|
" if i < len(DevList):\n",
|
|
" DevInfo = DevList[i]\n",
|
|
" hCamera = mvsdk.CameraInit(DevInfo, -1, -1)\n",
|
|
" capture_ready = test_camera_capture_readiness(hCamera)\n",
|
|
" print(f\"Capture Ready for {DevInfo.GetFriendlyName()}: {capture_ready}\")\n",
|
|
" mvsdk.CameraUnInit(hCamera)\n",
|
|
" else:\n",
|
|
" print(f\"Could not re-initialize camera {i}\")\n",
|
|
" except Exception as e:\n",
|
|
" print(f\"Error testing camera {i}: {e}\")\n",
|
|
"else:\n",
|
|
" print(\"\\nNo cameras are available for capture testing\")\n",
|
|
" print(\"Camera statuses:\")\n",
|
|
" for i, (cam_info, status) in enumerate(camera_results):\n",
|
|
" if hasattr(cam_info, 'GetFriendlyName'):\n",
|
|
" name = cam_info.GetFriendlyName()\n",
|
|
" else:\n",
|
|
" name = f\"Camera {i}\"\n",
|
|
" print(f\" {name}: {status}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 30,
|
|
"id": "comprehensive-check",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"==================================================\n",
|
|
"COMPREHENSIVE CAMERA CHECK\n",
|
|
"==================================================\n",
|
|
"Camera Availability Check\n",
|
|
"==============================\n",
|
|
"✓ SDK initialized successfully\n",
|
|
"✓ Found 2 camera(s)\n",
|
|
" 0: Blower-Yield-Cam (192.168.1.165-192.168.1.54)\n",
|
|
" 1: Cracker-Cam (192.168.1.167-192.168.1.54)\n",
|
|
"\n",
|
|
"Testing camera 0: Blower-Yield-Cam\n",
|
|
"✓ Camera is available (not opened by another process)\n",
|
|
"✓ Camera initialized successfully\n",
|
|
"✓ Camera closed after testing\n",
|
|
"\n",
|
|
"Testing camera 1: Cracker-Cam\n",
|
|
"✓ Camera is available (not opened by another process)\n",
|
|
"✓ Camera initialized successfully\n",
|
|
"✓ Camera closed after testing\n",
|
|
"\n",
|
|
"==================================================\n",
|
|
"FINAL RESULTS:\n",
|
|
"Camera Available: False\n",
|
|
"Capture Ready: False\n",
|
|
"Status: (42, 'AVAILABLE')\n",
|
|
"==================================================\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def comprehensive_camera_check():\n",
|
|
" \"\"\"\n",
|
|
" Complete camera availability and readiness check\n",
|
|
" Returns: (available, ready, handle_or_info, status_message)\n",
|
|
" \"\"\"\n",
|
|
" # Check availability\n",
|
|
" handle_or_info, status = check_camera_availability()\n",
|
|
" \n",
|
|
" available = status == \"AVAILABLE\"\n",
|
|
" ready = False\n",
|
|
" \n",
|
|
" if available:\n",
|
|
" # Test capture readiness\n",
|
|
" ready = test_camera_capture_readiness(handle_or_info)\n",
|
|
" \n",
|
|
" # Close camera after testing\n",
|
|
" try:\n",
|
|
" mvsdk.CameraUnInit(handle_or_info)\n",
|
|
" print(\"✓ Camera closed after testing\")\n",
|
|
" except:\n",
|
|
" pass\n",
|
|
" \n",
|
|
" return available, ready, handle_or_info, status\n",
|
|
"\n",
|
|
"# Run comprehensive check\n",
|
|
"print(\"\\n\" + \"=\" * 50)\n",
|
|
"print(\"COMPREHENSIVE CAMERA CHECK\")\n",
|
|
"print(\"=\" * 50)\n",
|
|
"\n",
|
|
"available, ready, info, status_msg = comprehensive_camera_check()\n",
|
|
"\n",
|
|
"print(\"\\n\" + \"=\" * 50)\n",
|
|
"print(\"FINAL RESULTS:\")\n",
|
|
"print(f\"Camera Available: {available}\")\n",
|
|
"print(f\"Capture Ready: {ready}\")\n",
|
|
"print(f\"Status: {status_msg}\")\n",
|
|
"print(\"=\" * 50)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 31,
|
|
"id": "status-check-function",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"Testing Simple Camera Ready Check:\n",
|
|
"========================================\n",
|
|
"Ready: True\n",
|
|
"Message: Camera 'Blower-Yield-Cam' is ready for capture\n",
|
|
"Camera: Blower-Yield-Cam\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def is_camera_ready_for_capture():\n",
|
|
" \"\"\"\n",
|
|
" Simple function to check if camera is ready for capture.\n",
|
|
" Returns: (ready: bool, message: str, camera_info: object or None)\n",
|
|
" \n",
|
|
" This is the function you can use in your main capture script.\n",
|
|
" \"\"\"\n",
|
|
" try:\n",
|
|
" # Initialize SDK\n",
|
|
" mvsdk.CameraSdkInit(1)\n",
|
|
" \n",
|
|
" # Enumerate cameras\n",
|
|
" DevList = mvsdk.CameraEnumerateDevice()\n",
|
|
" if len(DevList) < 1:\n",
|
|
" return False, \"No cameras found\", None\n",
|
|
" \n",
|
|
" DevInfo = DevList[0]\n",
|
|
" \n",
|
|
" # Check if already opened\n",
|
|
" try:\n",
|
|
" if mvsdk.CameraIsOpened(DevInfo):\n",
|
|
" return False, f\"Camera '{DevInfo.GetFriendlyName()}' is already opened by another process\", DevInfo\n",
|
|
" except:\n",
|
|
" pass # Some cameras might not support this check\n",
|
|
" \n",
|
|
" # Try to initialize\n",
|
|
" try:\n",
|
|
" hCamera = mvsdk.CameraInit(DevInfo, -1, -1)\n",
|
|
" \n",
|
|
" # Quick capture test\n",
|
|
" try:\n",
|
|
" # Basic setup\n",
|
|
" mvsdk.CameraSetTriggerMode(hCamera, 0)\n",
|
|
" mvsdk.CameraPlay(hCamera)\n",
|
|
" \n",
|
|
" # Try to get one frame with short timeout\n",
|
|
" pRawData, FrameHead = mvsdk.CameraGetImageBuffer(hCamera, 500) # 0.5 second timeout\n",
|
|
" mvsdk.CameraReleaseImageBuffer(hCamera, pRawData)\n",
|
|
" \n",
|
|
" # Success - close and return\n",
|
|
" mvsdk.CameraUnInit(hCamera)\n",
|
|
" return True, f\"Camera '{DevInfo.GetFriendlyName()}' is ready for capture\", DevInfo\n",
|
|
" \n",
|
|
" except mvsdk.CameraException as e:\n",
|
|
" mvsdk.CameraUnInit(hCamera)\n",
|
|
" if e.error_code == mvsdk.CAMERA_STATUS_TIME_OUT:\n",
|
|
" return False, \"Camera timeout - may be busy or not streaming properly\", DevInfo\n",
|
|
" else:\n",
|
|
" return False, f\"Camera capture test failed: {e.message}\", DevInfo\n",
|
|
" \n",
|
|
" except mvsdk.CameraException as e:\n",
|
|
" if e.error_code == mvsdk.CAMERA_STATUS_DEVICE_IS_OPENED:\n",
|
|
" return False, f\"Camera '{DevInfo.GetFriendlyName()}' is already in use\", DevInfo\n",
|
|
" elif e.error_code == mvsdk.CAMERA_STATUS_ACCESS_DENY:\n",
|
|
" return False, f\"Access denied to camera '{DevInfo.GetFriendlyName()}'\", DevInfo\n",
|
|
" else:\n",
|
|
" return False, f\"Camera initialization failed: {e.message}\", DevInfo\n",
|
|
" \n",
|
|
" except Exception as e:\n",
|
|
" return False, f\"Camera check failed: {str(e)}\", None\n",
|
|
"\n",
|
|
"# Test the simple function\n",
|
|
"print(\"\\nTesting Simple Camera Ready Check:\")\n",
|
|
"print(\"=\" * 40)\n",
|
|
"\n",
|
|
"ready, message, camera_info = is_camera_ready_for_capture()\n",
|
|
"print(f\"Ready: {ready}\")\n",
|
|
"print(f\"Message: {message}\")\n",
|
|
"if camera_info:\n",
|
|
" print(f\"Camera: {camera_info.GetFriendlyName()}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "usage-example",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Usage Example\n",
|
|
"\n",
|
|
"Here's how you can integrate the camera status check into your capture script:\n",
|
|
"\n",
|
|
"```python\n",
|
|
"# Before attempting to capture images\n",
|
|
"ready, message, camera_info = is_camera_ready_for_capture()\n",
|
|
"\n",
|
|
"if not ready:\n",
|
|
" print(f\"Camera not ready: {message}\")\n",
|
|
" # Handle the error appropriately\n",
|
|
" return False\n",
|
|
"\n",
|
|
"print(f\"Camera ready: {message}\")\n",
|
|
"# Proceed with normal capture logic\n",
|
|
"```\n",
|
|
"\n",
|
|
"## Key Findings\n",
|
|
"\n",
|
|
"1. **`CameraIsOpened()`** - Checks if camera is opened by another process\n",
|
|
"2. **`CameraInit()` error codes** - Provide specific failure reasons\n",
|
|
"3. **Quick capture test** - Verifies camera is actually streaming\n",
|
|
"4. **Timeout handling** - Detects if camera is busy/unresponsive\n",
|
|
"\n",
|
|
"The most reliable approach is to:\n",
|
|
"1. Check if camera exists\n",
|
|
"2. Check if it's already opened\n",
|
|
"3. Try to initialize it\n",
|
|
"4. Test actual image capture with short timeout\n",
|
|
"5. Clean up properly"
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "USDA-vision-cameras",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.11.2"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 5
|
|
}
|