qt 检测usb

qtusb.h

#ifndef QTUSB_H
#define QTUSB_H

#include <QObject>
#include <usb.h>
#include <QProcess>
class QtUsb : public QObject
{
    Q_OBJECT
private:
     const static int        INTERFACE = 0;
     const static int        CONFIGURATION = 1;
     const static int        ENDPOINT_IN = 0x81;
     const static int        ENDPOINT_OUT = 0x01;
     const static int        TIMEOUT = 5000;

     bool                    m_IsOpened;
     usb_dev_handle          *m_UsbDevice; //sudo apt-get install libusb-dev

     bool FindDevice (quint16 VendorId, quint16 ProductId);
       QProcess* cmd;
public:
    explicit QtUsb(QObject *parent = 0);
    bool Open (quint16 VendorId, quint16 ProductId);
        void Close ();
        bool Write (char *packet, quint8 size);
        bool Read (char *packet, quint8 size);


signals:

public slots:

        bool ReadUSB();
        QString ReadOutPut();

};

#endif // QTUSB_H

 

qtusb.cpp

#include "qtusb.h"
#include <QProcess>
#include <QMessageBox>
QtUsb::QtUsb(QObject *parent) :
    QObject(parent)
{
    this->m_IsOpened = false;
}
bool QtUsb::ReadUSB()
{
       cmd=new QProcess(this);
       QObject::connect(cmd,SIGNAL(readyRead()),this,SLOT(ReadOutPut()));
    cmd->start("ls /dev |grep ^sd");
     //cmd->start("ifconfig ");


// return true;
}


QString QtUsb::ReadOutPut()
{
    QString output =cmd->readAll();
    //QMessageBox::information(NULL, "output",output);

    if(output.indexOf("sdb1")>0)
    {
     QProcess::execute("mkdir /mnt/sdb1");
     QProcess::execute("mount /dev/sdb1 /mnt/sdb1");
    }

//    return output;
}

bool QtUsb::FindDevice(quint16 VendorId, quint16 ProductId)
 {
     struct usb_bus *bus;
     struct usb_device *dev;

     qDebug ("Scanning for device with VendorId = 0x%04x and ProductId = 0x%04x", VendorId, ProductId);
     usb_find_busses ();
     usb_find_devices ();

     for (bus = usb_get_busses(); bus; bus = bus->next)
     {
         for (dev = bus->devices; dev; dev = dev->next)
         {
             if (dev->descriptor.idVendor == VendorId && dev->descriptor.idProduct == ProductId)
             {
                 qDebug ("Device found");
                 if (!(this->m_UsbDevice = usb_open(dev)))
                 {
                     qCritical ("Could not open USB device");
                     return false;
                 }
                 this->m_IsOpened = true;
                 return true;
             }
         }
     }

     qDebug ("Cannot find specified device");
     return false;
 }

 bool  QtUsb::Open (quint16 VendorId, quint16 ProductId)
 {
     if (this->m_IsOpened) this->Close ();

     qDebug ("Initializing LibUSB");
     usb_init ();
     //usb_set_debug (255);

     if (!this->FindDevice (VendorId, ProductId)) return false;

 #ifndef Q_OS_WIN32
     if (usb_reset (this->m_UsbDevice))
     {
         qCritical ("Cannot reset usb connection.");
         this->Close ();
         return false;
     }
     qDebug ("Resetting usb connection.");
 #endif

     if (usb_set_configuration (this->m_UsbDevice, this->CONFIGURATION) < 0)
     {
         qCritical ("Cannot set configuration 1.");
         this->Close ();
         return false;
     }
     qDebug ("Configuration 1 setted");

     if (usb_claim_interface (this->m_UsbDevice, this->INTERFACE) < 0)
     {
         qCritical ("Cannot claim interface.");
         this->Close ();
         return false;
     }
     qDebug ("Interface claimed");

     return true;
 }

 bool QtUsb::Write (char *packet, quint8 size)
 {
     if (!this->m_IsOpened)
     {
         qCritical ("Usb connection not opened");
         return false;
     }

     if (usb_bulk_write (this->m_UsbDevice, this->ENDPOINT_OUT, packet, (int)size, this->TIMEOUT) < 0)
     {
         qCritical ("Bulk xfer write failed");
         return false;
     }
     return true;
 }

 bool QtUsb::Read (char *packet, quint8 size)
 {
     if (!this->m_IsOpened)
     {
         qCritical ("Usb connection not opened");
         return false;
     }

     if (usb_bulk_read (this->m_UsbDevice, this->ENDPOINT_IN, packet, (int)size, this->TIMEOUT) < 0)
     {
         qCritical ("Bulk xfer read failed");
         return false;
     }
     return true;
 }

 void QtUsb::Close ()
 {
     qDebug ("Closing LibUSB");
     usb_release_interface (this->m_UsbDevice, this->INTERFACE);
     usb_close (this->m_UsbDevice);
     this->m_IsOpened = false;
 }