精华内容
下载资源
问答
  • ubuntu-linux环境下,运行代码,系统读取USB摄像头数据,并实时显示摄像头采集的视频信息
  • Linux读取USB扫描枪数据

    千次阅读 2018-01-31 17:52:00
    1.USB扫描枪   USB接口的扫描枪相当于键盘...2.Linux读取数据 2.1扫描枪设备   USB扫描枪相当于一个键盘输入设备,Windows或者Linux下都集成相关驱动,或者免驱动。基于ARM下的Linux系统,接入扫描枪,在“/de

    1.USB扫描枪
      USB接口的扫描枪相当于键盘输入,在Windows或者Linux下,在成功安装驱动的前提下,打开文件编辑器如word、txt等。扫描枪读出到条码数据时,数据即被捕获到光标处。

    2.Linux下读取数据

    2.1扫描枪设备
      USB扫描枪相当于一个键盘输入设备,Windows或者Linux下都集成相关驱动,或者免驱动。基于ARM下的Linux系统,接入扫描枪,在“/dev/input”目录下可以查看该事件设备,如图,我这边的是“event1”。
    这里写图片描述

    2.1读取扫描枪数据
      基于Linux的“一切皆文件”的思想,通过上面的“event1”设备,即可获取USB扫描枪返回的数据。

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <linux/input.h>
    
    #define SCANNER_DEV "/dev/input/event1"
    
    struct input_event buff; 
    int fd; 
    int read_nu;
    
    int main(int argc, char *argv[])
    {
        fd = open(SCANNER_DEV, O_RDONLY);//打开usb扫描枪设备
        if (fd < 0)
        { 
            perror("can not open device usbscanner!"); 
            exit(1); 
        } 
        int i = 0;
        printf("--fd:%d--\n",fd);
        while(1)
        {
            while(read(fd,&buff,sizeof(struct input_event))==0)
            {
                ;
            }
            printf("type:%d code:%d value:%d\n",buff.type,buff.code,buff.value); 
        }
        close(fd); 
        return 1;
    }

    其中关键结构体input_event,在“linux/input.h”中有定义

    struct input_event
    {
    struct timeval time;
    __u16 type;
    __u16 code;
    __s32 value;
    };

    type:设备类型,如0表示是键盘,1表示是鼠标,和其他等;
    code:键码值;
    value:对于不同的类型设备,该值有不同的含义;对于键盘设备来说,0表示未按下(松开),1表示按下,2表示一直按下。
    详细的“input_event”参考后面参考链接文章。

    3.参考

    [1] http://blog.csdn.net/bingqingsuimeng/article/details/8178122

    展开全文
  • linux下如何读取usb

    千次阅读 2004-07-29 22:01:00
    linux下忧盘被作为SCSI设备,挂载优盘前首先确认优盘设备名,在终端输入dmesg|more查看,我的是sda1 建立挂载点/mnt/usb 然后用mount -t vfat /dev/sda1 /mnt/usb挂载即可,或者通过在fstab中加入/dev/sda1 /mnt/usb ...

    在linux下忧盘被作为SCSI设备,挂载优盘前首先确认优盘设备名,在终端输入dmesg|more查看,我的是sda1
    建立挂载点/mnt/usb
    然后用mount -t vfat /dev/sda1 /mnt/usb挂载即可,或者通过在fstab中加入/dev/sda1 /mnt/usb vfat defaults 0 0开机自动挂载,但用defaults参数,如果开机时优盘没有插上,就会报错.
    所以我是在fstab中加入/dev/sda1 /mnt/usb vfat noauto 0 0,然后在桌面上新建一个硬盘设备的链接,在链接属性的设备选项卡选择设备为/dev/sda1(/mnt/usb)半自动挂载.以后要用优盘时,只要点击这个链接就可以了.

    展开全文
  • ubuntu-Linux系统读取USB摄像头数据(uvc)

    万次阅读 2016-12-23 11:46:40
    #include <linux/videodev2.h> #include #include #include #include void quit(const char * msg) { fprintf(stderr, "[%s] %d: %s\n", msg, errno, strerror(errno)); exit(EXIT_FAILURE); } int xioctl...

    这几天在做小车的过程中,需要用到图像采集。我想现在用的摄像头是UVC免驱的。根据国嵌的教程中有一个gspca摄像头的程序。我发现把gspca的采集程序用到uvc上时,在显示图像的时候提示没有huffman表。但是在显示gspca的摄像头时却没有问题。为此特别找了以下的程序来获取uvc摄像头的数据。

    程序代码:

    /*
     * capturing from UVC cam
     * requires: libjpeg-dev
     * build: gcc -std=c99 capture.c -ljpeg -o capture
     */
    
    #include <stdint.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    
    #include <fcntl.h>
    #include <sys/ioctl.h>
    #include <sys/mman.h>
    #include <asm/types.h>
    #include <linux/videodev2.h>
    
    #include <sys/time.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    #include <jpeglib.h>
    
    void quit(const char * msg)
    {
      fprintf(stderr, "[%s] %d: %s\n", msg, errno, strerror(errno));
      exit(EXIT_FAILURE);
    }
    
    int xioctl(int fd, int request, void* arg)
    {
      for (int i = 0; i < 100; i++) {
        int r = ioctl(fd, request, arg);
        if (r != -1 || errno != EINTR) return r;
      }
      return -1;
    }
    
    typedef struct {
      uint8_t* start;
      size_t length;
    } buffer_t;
    
    typedef struct {
      int fd;
      uint32_t width;
      uint32_t height;
      size_t buffer_count;
      buffer_t* buffers;
      buffer_t head;
    } camera_t;
    
    
    camera_t* camera_open(const char * device, uint32_t width, uint32_t height)
    {
      int fd = open(device, O_RDWR | O_NONBLOCK, 0);
      if (fd == -1) quit("open");
      camera_t* camera = malloc(sizeof (camera_t));
      camera->fd = fd;
      camera->width = width;
      camera->height = height;
      camera->buffer_count = 0;
      camera->buffers = NULL;
      camera->head.length = 0;
      camera->head.start = NULL;
      return camera;
    }
    
    
    void camera_init(camera_t* camera) {
      struct v4l2_capability cap;
      if (xioctl(camera->fd, VIDIOC_QUERYCAP, &cap) == -1) quit("VIDIOC_QUERYCAP");
      if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) quit("no capture");
      if (!(cap.capabilities & V4L2_CAP_STREAMING)) quit("no streaming");
    
      struct v4l2_cropcap cropcap;
      memset(&cropcap, 0, sizeof cropcap);
      cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (xioctl(camera->fd, VIDIOC_CROPCAP, &cropcap) == 0) {
        struct v4l2_crop crop;
        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        crop.c = cropcap.defrect;
        if (xioctl(camera->fd, VIDIOC_S_CROP, &crop) == -1) {
          // cropping not supported
        }
      }
    
      struct v4l2_format format;
      memset(&format, 0, sizeof format);
      format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      format.fmt.pix.width = camera->width;
      format.fmt.pix.height = camera->height;
      format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
      format.fmt.pix.field = V4L2_FIELD_NONE;
      if (xioctl(camera->fd, VIDIOC_S_FMT, &format) == -1) quit("VIDIOC_S_FMT");
    
      struct v4l2_requestbuffers req;
      memset(&req, 0, sizeof req);
      req.count = 4;
      req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      req.memory = V4L2_MEMORY_MMAP;
      if (xioctl(camera->fd, VIDIOC_REQBUFS, &req) == -1) quit("VIDIOC_REQBUFS");
      camera->buffer_count = req.count;
      camera->buffers = calloc(req.count, sizeof (buffer_t));
    
      size_t buf_max = 0;
      for (size_t i = 0; i < camera->buffer_count; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof buf);
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        if (xioctl(camera->fd, VIDIOC_QUERYBUF, &buf) == -1)
          quit("VIDIOC_QUERYBUF");
        if (buf.length > buf_max) buf_max = buf.length;
        camera->buffers[i].length = buf.length;
        camera->buffers[i].start =
          mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED,
               camera->fd, buf.m.offset);
        if (camera->buffers[i].start == MAP_FAILED) quit("mmap");
      }
      camera->head.start = malloc(buf_max);
    }
    
    
    void camera_start(camera_t* camera)
    {
      for (size_t i = 0; i < camera->buffer_count; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof buf);
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        if (xioctl(camera->fd, VIDIOC_QBUF, &buf) == -1) quit("VIDIOC_QBUF");
      }
    
      enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (xioctl(camera->fd, VIDIOC_STREAMON, &type) == -1)
        quit("VIDIOC_STREAMON");
    }
    
    void camera_stop(camera_t* camera)
    {
      enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (xioctl(camera->fd, VIDIOC_STREAMOFF, &type) == -1)
        quit("VIDIOC_STREAMOFF");
    }
    
    void camera_finish(camera_t* camera)
    {
      for (size_t i = 0; i < camera->buffer_count; i++) {
        munmap(camera->buffers[i].start, camera->buffers[i].length);
      }
      free(camera->buffers);
      camera->buffer_count = 0;
      camera->buffers = NULL;
      free(camera->head.start);
      camera->head.length = 0;
      camera->head.start = NULL;
    }
    
    void camera_close(camera_t* camera)
    {
      if (close(camera->fd) == -1) quit("close");
      free(camera);
    }
    
    
    int camera_capture(camera_t* camera)
    {
      struct v4l2_buffer buf;
      memset(&buf, 0, sizeof buf);
      buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      buf.memory = V4L2_MEMORY_MMAP;
      if (xioctl(camera->fd, VIDIOC_DQBUF, &buf) == -1) return FALSE;
      memcpy(camera->head.start, camera->buffers[buf.index].start, buf.bytesused);
      camera->head.length = buf.bytesused;
      if (xioctl(camera->fd, VIDIOC_QBUF, &buf) == -1) return FALSE;
      return TRUE;
    }
    
    int camera_frame(camera_t* camera, struct timeval timeout) {
      fd_set fds;
      FD_ZERO(&fds);
      FD_SET(camera->fd, &fds);
      int r = select(camera->fd + 1, &fds, 0, 0, &timeout);
      if (r == -1) quit("select");
      if (r == 0) return FALSE;
      return camera_capture(camera);
    }
    
    
    void jpeg(FILE* dest, uint8_t* rgb, uint32_t width, uint32_t height, int quality)
    {
      JSAMPARRAY image;
      image = calloc(height, sizeof (JSAMPROW));
      for (size_t i = 0; i < height; i++) {
        image[i] = calloc(width * 3, sizeof (JSAMPLE));
        for (size_t j = 0; j < width; j++) {
          image[i][j * 3 + 0] = rgb[(i * width + j) * 3 + 0];
          image[i][j * 3 + 1] = rgb[(i * width + j) * 3 + 1];
          image[i][j * 3 + 2] = rgb[(i * width + j) * 3 + 2];
        }
      }
    
      struct jpeg_compress_struct compress;
      struct jpeg_error_mgr error;
      compress.err = jpeg_std_error(&error);
      jpeg_create_compress(&compress);
      jpeg_stdio_dest(&compress, dest);
    
      compress.image_width = width;
      compress.image_height = height;
      compress.input_components = 3;
      compress.in_color_space = JCS_RGB;
      jpeg_set_defaults(&compress);
      jpeg_set_quality(&compress, quality, TRUE);
      jpeg_start_compress(&compress, TRUE);
      jpeg_write_scanlines(&compress, image, height);
      jpeg_finish_compress(&compress);
      jpeg_destroy_compress(&compress);
    
      for (size_t i = 0; i < height; i++) {
        free(image[i]);
      }
      free(image);
    }
    
    
    int minmax(int min, int v, int max)
    {
      return (v < min) ? min : (max < v) ? max : v;
    }
    
    uint8_t* yuyv2rgb(uint8_t* yuyv, uint32_t width, uint32_t height)
    {
      uint8_t* rgb = calloc(width * height * 3, sizeof (uint8_t));
      for (size_t i = 0; i < height; i++) {
        for (size_t j = 0; j < width; j += 2) {
          size_t index = i * width + j;
          int y0 = yuyv[index * 2 + 0] << 8;
          int u = yuyv[index * 2 + 1] - 128;
          int y1 = yuyv[index * 2 + 2] << 8;
          int v = yuyv[index * 2 + 3] - 128;
          rgb[index * 3 + 0] = minmax(0, (y0 + 359 * v) >> 8, 255);
          rgb[index * 3 + 1] = minmax(0, (y0 + 88 * v - 183 * u) >> 8, 255);
          rgb[index * 3 + 2] = minmax(0, (y0 + 454 * u) >> 8, 255);
          rgb[index * 3 + 3] = minmax(0, (y1 + 359 * v) >> 8, 255);
          rgb[index * 3 + 4] = minmax(0, (y1 + 88 * v - 183 * u) >> 8, 255);
          rgb[index * 3 + 5] = minmax(0, (y1 + 454 * u) >> 8, 255);
        }
      }
      return rgb;
    }
    
    
    int main()
    {
      camera_t* camera = camera_open("/dev/video0", 352, 288);
      camera_init(camera);
      camera_start(camera);
    
      struct timeval timeout;
      timeout.tv_sec = 1;
      timeout.tv_usec = 0;
      /* skip 5 frames for booting a cam */
      for (int i = 0; i < 5; i++) {
        camera_frame(camera, timeout);
      }
      camera_frame(camera, timeout);
    
      unsigned char* rgb =
        yuyv2rgb(camera->head.start, camera->width, camera->height);
      FILE* out = fopen("result.jpg", "w");
      jpeg(out, rgb, camera->width, camera->height, 100);
      fclose(out);
      free(rgb);
    
      camera_stop(camera);
      camera_finish(camera);
      camera_close(camera);
      return 0;
    }

    u-boot下载地址: ftp://ftp.denx.de/pub/u-boot/

    linux内核下载地址: https://www.kernel.org/pub/linux/kernel


    转载地址:http://www.cnblogs.com/ynxf/p/6137091.html

    展开全文
  • virtualBox虚拟机下LinuxUSB读取设置

    千次阅读 2018-06-02 23:21:04
    VirtualBox版本:5.2.12-122591 Linux:CentOS6.5 水平有限,如果没有解决您的问题,请谅解。 问题起因: 用fdisk -l 命令时,始终没有显示到U盘的路径,也就因此无法对U盘进行挂载等操作 问题的解决方案: ...

    因为在网上没有搜索到相关的解决文章,所以决定单独写一篇解决博客

    VirtualBox版本:5.2.12-122591 Linux:CentOS6.5

    水平有限,如果没有解决您的问题,请谅解。

    问题起因:

    用fdisk -l 命令时,始终没有显示到U盘的路径,也就因此无法对U盘进行挂载等操作
    

    问题的解决方案:

    首先关闭Linux,打开虚拟机,点击要操作的Linux系统CentOS6.5的设置界面。
    
    选择USB设备,点击添加图标,在里面找到你的U盘,然后选择OK。
    
    如果这里报错,错误提示,没有对应的磁盘空间,则看下一步。若未报错,则问题解决。
    
    先在控制器:SATA创建一个新的虚拟盘,然后选择专家模式,选择对应的大小位置,虚拟硬盘的文件类型选择VDI磁盘映像,然后选择创建。
    
    然后再重复上述USB操作。
    
    问题解决。
    

    解决结果:

    重新进入Linux系统中,输入fdisk -l 命令,对应U盘路径显示
    
    展开全文
  • Ubuntu 10.04 无法播放,摄像头是USB2.0接口,但 lsusb 命令只有foundation root 1.1 ,换用 Ubuntu 12.04,gstreamer-properties 只能播放前几帧数据就卡住了,提示: gstreamer-properties-Message: Error running...
  • Linux环境下使用V4L2+opencv以MJPEG格式读取USB摄像头并实时显示.pdf
  • Linux读取U盘内容

    2021-04-28 16:45:51
    查找设备 sudo fdisk -l 创建挂载点 sudo mkdir /mnt/usb 将存储设备进行挂载 ...sudo mount /dev/sda1 /mnt/usb ...cd /mnt/usb ...sudo umount /mnt/usb ...ubuntu linux读取U盘_mengxiangjia_linxi的博客-CSDN博客 ...
  • 转眼间,V4L2已经搞了很长时间,从最开始的一窍不通,到后来的渐渐熟悉,从最开始照猫画虎的使用YUYV格式之间转换,到后来使用MJPEG格式读取,中间颇有周折。趁任务完成间隙,来简单总结下V4L2的使用。(文章只主要...
  • linux驱动之usb鼠标按键的读取

    千次阅读 2015-01-01 18:07:14
    上一篇博文只是usb总线驱动程序的框架,下面来真正写一个usb驱动程序。 USB鼠标驱动,鼠标输入HID类型,其数据传输采用中断URB,鼠标端点类型为IN 目的:usb鼠标按键的驱动代码编写: 框架: 分配一个...
  • v4l2读取USB摄像头

    2018-03-08 13:13:54
    V4l2读取USB摄像头MJPG和yuyv数据,并实时显示摄像头的数据
  • 读取USB摄像头程序

    2013-03-08 18:32:08
    利用VC++与OPENCV读取USB摄像头程序,有需要的童鞋可以下载噢
  • qt读取usbhid硬件设备

    2019-09-05 15:46:36
    3 轴 8 按键 Joystick 的驱动程序。使用的是微软的 multimedia joystick API。可直接读取usbhid设备的四种摇杆方向按键及32种按键,并获取各种按键的增量值,异步方式使用,通过信号和槽连接即可直接使用
  • linux读取U盘操作

    万次阅读 2018-03-20 09:30:58
    1.查看挂载设备cd /devls列表中sda表示磁盘,sdb表示外部设备,...新建一个usb文件夹用来承接U盘文件mkdir usb如果报错不允许建文件夹sudo mkdir usbls现在mnt文件夹下面多了一个文件夹usb3.使用mount命令挂载设备...
  • 读取USB串口数据

    2021-02-25 10:27:05
    读取USB串口数据 RXTX的使用 下载RXTX库对应的资源文件。下载地址 http://fizzed.com/oss/rxtx-for-java 根据自己的系统下载对应的文件。 官方的使用方法是: -1-: window平台: 拷贝 rxtxSerial.dll —> <...
  • ubuntu linux读取U盘

    万次阅读 2017-09-22 21:20:40
    VMware虚拟机怎么连接U盘 | VMware读取U盘的设置方法转载地址:http://www.xitongcheng.com/jiaocheng/xtazjc_article_15126.html虚拟机VMware可以安装各种操作系统,部分用户需要在虚拟机中使用U盘Ubuntu读取U盘...
  • 读取USB摄像头的音频数据

    千次阅读 2019-06-20 11:19:39
    文章目录命令操作USB音频设备文件wav文件格式解析RIFF区fromat区data区gstreamer 合成音频为MP3文件用代码读取USB音频文件 之前的一直在操作USB摄像头的视频数据,如今需要读取USB摄像头的音频数据,进行音视频的...
  • LinuxUSB Camera的使用

    千次阅读 2020-06-02 10:35:29
    Linux下USB Camera的使用查看摄像头usb信息查看video设备文件查看camera信息查看系统能否识别出camera通过luvcview查看安装luvcview查看视频opencv c++读取usb camera数据参考 支持yuv协议的camera通过usb连接上电脑...
  • linux usb

    千次阅读 2015-04-13 18:01:40
    简述USB 系统概述USB 连接的基本知识 OTG 控制器  OTG 的基本概念 Linux 下的 OTG 架构 EHCI控制器 ...Linux中EHCI控制器驱动的架构 ...Linux中的USB设备驱动 USB设备的识别过程 USB设备的调试
  • Jetson nano读取USB摄像头比较简单,只需要两步:打开摄像头;逐帧提取。但是需要注意的是Jetson Nano并不是支持所有的USB摄像头,建议在采购的时候尽量选择Linux免驱的USB摄像头。
  • 其中最后一个例子step 5 是个通用驱动,应用层打开驱动设备文件,如同用串口设备一样简单就能读取usb数据,usb应用层包协议可以自己定。 因为linux驱动屏蔽硬件层,并且该设备不是什么标准设备,所以没有类似IIC...
  • 在嵌入式系统的开发中,编写设备驱动程序是必须要做的工作。本文给出了USB驱动程序的编写的架构,包括发现设备、读取设备信息、编写设备操作函数和注册、注销设备等操作,并给出了键盘飞梭驱动程序完整实例。
  • Linux 查看usb设备信息

    万次阅读 2016-12-15 23:49:13
    一、cat设备节点获取信息在一些嵌入式开发中需要调试USB功能,经常会cat /sys 下的相关设备节点来查看某些信息,比如说我们可以进入 /sys/bus/usb/devices 目录下可以看到以下目录。进入到对应的目录也可以看到usb...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,106
精华内容 14,842
关键字:

linux读取usb

linux 订阅