Question

我正试图在激光三角测量的基础上使用相机和Raspberry Pi 制作红外线范围传感器。程序运行在开始时相当顺利，但在 7秒之后，相机突然消失。我收到以下错误

“ VIDIOC_DQBUF：没有此类设备”

“无法停止播放：无此类设备＆＃34;

我还注意到相机改变了＆＃34; video1＆＃34;到＆＃34; video2＆＃34;。但是，重启后，它会转回＆＃34; video1＆＃34;

我将不胜感激任何帮助。谢谢

来自dmesg的消息。

因为它太长了，我不会在这里发布

这是我的代码（python）：

import RPi.GPIO as GPIO
import libscan 
import time
###############################################################
GPIO.setmode(GPIO.BCM) #turn on the infrared light
GPIO.setup(22, GPIO.OUT) 
GPIO.output(22,GPIO.LOW)
s=time.time() 
i=0 
pixel=0.00002
camera_value=[]

libscan.scan_grey_initial()#initialize the camera
while time.time()-s<=10:
    i+=1
    a=libscan.scan_grey(pixel)
    print len(a)
libscan.scan_grey_release()#release capture
print "total times:",i
print "fps:",i//10
GPIO.output(22,GPIO.HIGH)

这是我的c ++代码（编译为模块＆＃34; libscan＆＃34;）：使用命名空间cv; 使用namespace std;

typedef vector < vector<float> > scanvector;
static scanvector real_points;
static vector < vector<int> > original_points;
static vector<int> get_point;
static vector<float> processed_point;

static CvCapture* camera_first;
static CvCapture* camera_second;
vector<float> calpoint(float d0,float d1,float d2,float f,vector<float> c)
{
    float dz,dx;
    dz=(d1*d2)/d0;
    dx=(d1*f)/d0;
    c.push_back(dx);
    c.push_back(dz);
    return c;
}


int cam_first_initial()
{
    camera_first=cvCreateCameraCapture(1);
    cvSetCaptureProperty(camera_first, CV_CAP_PROP_FRAME_WIDTH, 320);
    cvSetCaptureProperty(camera_first, CV_CAP_PROP_FRAME_HEIGHT, 240);


    if(!camera_first)
    {
        printf("%s","Create connection 1 failed");
        return 1;
    }

    else
    {
        return 0;
    }
}
int cam_second_initial()
{
    camera_second=cvCreateCameraCapture(0);
    cvSetCaptureProperty(camera_second, CV_CAP_PROP_FRAME_WIDTH, 320);
    cvSetCaptureProperty(camera_second, CV_CAP_PROP_FRAME_HEIGHT, 240);

    if(!camera_second)
    {
        printf("%s","Create connection 2 failed");
        return 1;
    }

    else
    {
        return 0;
    }
}

scanvector scan_grey(float pixel)
{
    Mat frame;
    Mat grey;
    if (camera_first!=NULL)
    {
        read:
        frame=cvQueryFrame(camera_first);
        if(!frame.empty())
        {
            cvtColor(frame,grey,CV_BGR2GRAY);
            real_points.clear();
            cv::Mat_<uchar> grey2 = grey;
                for(int y0 = 0;y0 < grey.rows;y0++)
                {

                    original_points.clear();
                 for(int x0 = 0;x0 < grey.cols;x0++)
                  {

                    if(grey2(y0,x0)>= 250)
                    {

                        get_point.push_back(x0);
                        get_point.push_back(y0);
                        original_points.push_back(get_point);
                        get_point.clear();
                    }
                  }
                 if (original_points.size()<=2||original_points.size()>=15)
                 {
                     //empty
                 }
                 else if(original_points.size()>2&&original_points.size()<15)
                 {
                     get_point=original_points[original_points.size()/2];//两元素均为int是整除，否则为普通除
                     float d0=abs(get_point[0]-grey.cols/2)*pixel;
                     float d2=abs(get_point[1]-grey.rows/2)*pixel;
                     real_points.push_back(calpoint(d0,0.05,d2,0.018,processed_point));
                     processed_point.clear();
                 }

                }
            return real_points;
        }
        else
        {
            goto read;
        }
    }
    else
    {
        printf("%s\n","The camera is not initialized.");
        printf("%s\n","Initializing.");

        cam_first_initial();

        real_points.clear();
        return real_points;
    }

}
scanvector scan_rgb(float pixel)
{
    Mat frame;
    Mat frame_second;
    Mat grey;
    if (camera_first!=NULL&&camera_second!=NULL)
    {
        read2:
        frame=cvQueryFrame(camera_first);
        frame_second=cvQueryFrame(camera_second);
        if (!frame.empty()&&!frame_second.empty())
        {
            cvtColor(frame,grey,CV_BGR2GRAY);
            cv::Mat_<uchar> rgb=frame_second;
            cv::Mat_<uchar> grey2 = grey;

            real_points.clear();
                for(int y0 = 0;y0 < grey.rows;y0++)
                {
                    original_points.clear();
                 for(int x0 = 0;x0 < grey.cols;x0++)
                  {
                    if(grey2(y0,x0)>= 250)
                    {
                        uchar* data=rgb.ptr<uchar>(y0,grey.cols-x0);//original:bgr
                        int r=(int)data[2];
                        int g=(int)data[1];
                        int b=(int)data[0];
                        int rgb=((int)r << 16 | (int)g << 8 | (int)b);
                        float frgb=*reinterpret_cast<float*>(&rgb);
                        get_point.push_back(x0);
                        get_point.push_back(y0);
                        get_point.push_back(frgb);
                        original_points.push_back(get_point);
                        get_point.clear();
                    }
                  }
                 if (original_points.size()<=2||original_points.size()>=15)
                 {
                     //empty
                 }
                 else if(original_points.size()>2&&original_points.size()<15)
                 {
                     get_point=original_points[original_points.size()/2];//两元素均为int是整除，否则为普通除
                     float d0=abs(get_point[0]-grey.cols/2)*pixel;
                     float d2=abs(get_point[1]-grey.rows/2)*pixel;

                     calpoint(d0,0.05,d2,0.018,processed_point);
                     processed_point.push_back(get_point[2]);//frgb data

                     real_points.push_back(processed_point);
                     processed_point.clear();
                 }

                }
            return real_points;
        }
        else
        {
            goto read2;
        }
    }
    else
    {
        printf("%s\n","The cameras are not initialized.");
        printf("%s\n","Initializing.");
        cam_first_initial();
        cam_second_initial();
        real_points.clear();
        return real_points;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static PyObject* scan_grey_initial(PyObject *self,PyObject *args)
{
    int a=cam_first_initial();
    if(a!=1)
    {
        PyObject* result=Py_BuildValue("i",0);
        return result;
    }
    else
    {
        PyObject* result=Py_BuildValue("i",1);
        return result;
    }
}
static PyObject* scan_rgb_initial(PyObject *self,PyObject *args)
{

    int a=cam_first_initial();
    int b=cam_second_initial();
    if(a!=1&&b!=1)
    {
        PyObject* result=Py_BuildValue("i",0);
        return result;
    }
    else
    {
        PyObject* result=Py_BuildValue("i",1);
        return result;
    }
}
static PyObject* scan_grey_release(PyObject *self,PyObject *args)
{
    cvReleaseCapture(&camera_first);
    PyObject* result=Py_BuildValue("i",0);
    return result;
}
static PyObject* scan_rgb_release(PyObject *self,PyObject *args)
{
    cvReleaseCapture(&camera_first);
    cvReleaseCapture(&camera_second);
    PyObject* result=Py_BuildValue("i",0);
    return result;
}
static PyObject* scan_grey(PyObject *self,PyObject *args)
{
    float pixel;
    if(!PyArg_ParseTuple(args,"f",&pixel))
    return NULL;
    PyObject* result = PyList_New(0);
    scan_grey(pixel);
    if (real_points.size()==0)
    {
        return result;
    }
    else
    {
        for (int i = 0; i < real_points.size(); i++)
        {
            float realx=real_points[i][0];
            float realz=real_points[i][1];
            PyList_Append(result,Py_BuildValue("[f,f,f]",realx,0.0,realz));
        }

        return result;
    }
}
static PyObject* scan_rgb(PyObject *self,PyObject *args)
{
    float pixel;
    if(!PyArg_ParseTuple(args,"f",&pixel))
    return NULL;
    PyObject* result = PyList_New(0);
    scan_rgb(pixel);
    if (real_points.size()==0)
    {
        return result;
    }
    else
    {
        for (int i = 0; i < real_points.size(); i++)
        {
            float realx=real_points[i][0];
            float realz=real_points[i][1];
            float realrgb=real_points[i][2];
            PyList_Append(result,Py_BuildValue("[f,f,f,f]",realx,0.0,realz,realrgb));//realy->z
        }
        return result;
    }
}

static PyMethodDef wrap_methods[] ={
    {"scan_grey_initial", scan_grey_initial, METH_VARARGS},
    {"scan_grey_release", scan_grey_release, METH_VARARGS},
    {"scan_rgb_initial", scan_rgb_initial, METH_VARARGS},
    {"scan_rgb_release", scan_rgb_release, METH_VARARGS},
    {"scan_grey", scan_grey, METH_VARARGS},
    {"scan_rgb", scan_rgb, METH_VARARGS},
    {NULL, NULL}
};
PyMODINIT_FUNC initlibscan (void)
{
    Py_InitModule("libscan", wrap_methods);
}

运行opencv程序时相机突然消失

0 个答案: