Ho un device manager (vedi sotto) singleton il quale crea una lista di puntatori ad oggetti Device sul quale posso fare la ricerca di uno che corrisponde a vid e pid specificati tramite:
- Codice: Seleziona tutto
QList<Device *> getDevicesFromVendor(uint16_t _vendor, uint16_t _product);
Il quale ritorna una lista di puntatori da cui posso scegliere il device che mi interessa.
Classe DeviceManager
- Codice: Seleziona tutto
#ifndef DEVICEMANAGER_H
#define DEVICEMANAGER_H
#include <openusb.h>
#include "device.h"
#include <QObject>
#include <QList>
#include <QPair>
#include <QMap>
#include <QDebug>
namespace System {
namespace Usb {
class DeviceManager : public QObject
{
Q_OBJECT
public:
static DeviceManager *instance() {
if (!m_instance) {
m_instance = new DeviceManager;
m_instance->init();
qDebug() << "crea nuova instanza di DeviceManager";
} else {
;
}
qDebug() << "ritorna l'instanza di DeviceManager" << m_instance ;
return m_instance;
}
openusb_handle_t handle() { return libhandle; }
QList<Device *> getDevicesFromVendor(uint16_t _vendor, uint16_t _product);
~DeviceManager();
int lastError();
private:
static DeviceManager *m_instance;
DeviceManager();
DeviceManager(const DeviceManager &);
DeviceManager &operator=(const DeviceManager &);
openusb_handle_t libhandle;
openusb_devid_t *devids;
uint32_t devnum;
uint32_t busnum;
openusb_busid_t *bus;
//struct usb_device_desc devDescriptor;
QMap<int /*devEnum*/, Device *> enumeratorDeviceMap;
QList<Device *> garbage;
void doGarbage() {
if (garbage.count())
foreach (Device* dev, garbage) {
delete dev;
}
}
static bool disableEvent;
bool needUpdate;
static void eventHandling(openusb_handle_t handle, openusb_devid_t devid,
openusb_event_t event, void *arg);
int _lastError;
void eventSlot(uint8_t event, uint16_t enumDev);
uint16_t eventDeviceId;
signals:
void systemDeviceConnected(uint16_t deviceId);
void systemDeviceDisconnected(uint16_t deviceId);
void systemDeviceChanged();
public slots:
private slots:
void init();
void deviceAttached();
void deviceRemoved();
};
} // Usb namespace
} // System namespace
#endif // DEVICEMANAGER_H
Il device manager sembra funzionare, brevemente lo spiego:
eventHandling è statica ma dovrà essere una funzione friend perchè è la callback da passare alla libreria openusb, comunque così funziona anche se ho duvuto fare un magheggio che spero di evitare con eventHandling friend.
Ogni volta che un device viene rimosso, il puntatore a Device* viene rimosso dalla lista e messo in garbage, così ogni volta che richiamo il metodo instance() se garbage.count() è vera ci sono oggetti da distruggere.
Ora il problema si sposta sul device:
Un device usb è composto da varie interfaccie che possono avere più endpoint con cui dialogare, per cui un device è un contenitore di interfaccia ed endpoint. La cosa che mi è venuta in mente subito è: eredito QIODevice in ogni classe Device, ma QIODevice ha un solo buffer interno e posso leggere e scrivere su un solo endpoint, quindi come faccio a modellare il device usb?
Ho pensato a queste due possibilità:
Nota
evice eredita QObjectCreao una classe EndPoint(Device*) che eredita QIODevice, EndPoin sa come usare un Device* e quindi finisco per creare solo gli endpoint che mi servono.
Oppure:
Chiedo a device di creare un'oggetto di classe EndPoint e su questo opero con i metodi di QIODevice.
Per adesso ho scritto solo codice per prendere confidenza con openusb e sono riuscito a comunicare con un device AVRISP MKII inviandoglio il comando CMD_SIGN_ON
e leggendo la risposta prevista composta da:
1 byte STATUS_CMD_OK 0
1 byte Signature length 10
10 byte String “AVRISP_MK2” No null terminated
Voi come procedereste?
Ciao.