Libreria Qtk8055 Per Vm110N O K8055

[Marco Mondin]

Da poco ho acquistato una scheda VM110n (K8055).
Dopo averla analizzata un po' ho deciso di scrivere un'ennesima libreria, in questo caso in C++.

Per ora è in fase embrionale su gitorious al seguente link https://gitorious.org/qtk8055.

Si appoggia alle librerie QT ed alla libreria libUSB 1.0, questo la rende altamente portabile e non dipendente dal sistema operativo.

A differenza di varie altre librerie per K8055 permette di essere usata in multithreading grazie al sistema di scambio SIGALS/SLOT delle librerie QT.
Ha anche la possibilità di gestire un controllo ciclico con rispettiva emissione di eventi sotto forma di SIGNALS in modo autonomo.

Allo stesso link si trovano sia la libreria in versione alpha come QtK8055-alpha-1 che il rispettivo software di test come QtK8055Test, il quale ricopia a grandi linee quello fornito dalla velleman e può essere analizzato per capire l'utilizzo della libreria fino a quando non aggiungerò la documentazione.

Per ora sono implementati tutti gli SLOTS e i SIGNALS che ho previsto per il rilascio della prima beta, mentre mancano ancora la maggior parte dei metodi per accesso diretto (diciamo tradizionale come nelle librerie già esistenti).

L'obbiettivo futuro è quello di abbinarla a sistemi simili ai Raspberry PI per creare una sorta di box per automazione generica molto astratto per applicazioni custom gestibile da WEB.

Per poter usare tale libreria sono necessarie le librerie QT con relativi tool di sviluppo, e la libreria libUSB-1.0 con relativi headers.

[Marco Mondin]

Ho finito le implementazioni per passare alla fase di beta testing. Ho anche aggiunto un po' di documentazione.

Ecco una veloce descrizione (reference manual) di cosa fa questa libreria.

-----
QK8055 Class

The QK8055 class provides an interface to Velleman K8055 and VM100n boards.

In sources:
#include <QtK8055/QtK8055.h>

In project files:
LIBS += -lQtK8055

Inherits: QObject.

----
Public Functions

QK8055(QObject * parent = 0)

~QK8055()


int maxDevices()
const QList<int> &openedDevicesPorts()

bool readDigitalInput(int port, int channel)
int readAllDigitalInput(int port)
int raedAnalog0(int port)
int raedAnalog1(int port)
int raedCounter0(int port)
int raedCounter1(int port)
----
SIGNALS
void InputChanged()
void errorK8055(int code)
void errorK8055(QString error)
void digitalChanged(int port, int bitmask)
void digitalActivated(int port, int channel)
void digitalUnactivated(int port, int channel)
void analog0Changed(int port, int value)
void analog1Changed(int port, int value)
void counter0Changed(int port, int value)
void counter1Changed(int port, int value)
void digitalOutputChanged(int port, int bitmask)
void digitalOutActivated(int port, int channel)
void digitalOutUnactivated(int port, int channel)
void analogOut0Changed(int port, int value)
void analogOut1Changed(int port, int value)
void debounce0Changed(int port, int value)
void debounce1Changed(int port, int value)

-----
Public SLOTS
void openDevice(int port)
void closeDevice(int port)

void startTimingLoop(int msec)
void stopTimingLoop()
viod setQuickModeOn(bool status=true)
void setQuickModeOff(bool status=true)

void setAllDigital(int port, int bitmask)
void resetAllDigital(int port);
void setDigitalOn(int port, int channel, bool status=true)
void setDigitalOff(int port, int channel, bool status=true)
void setAllAnalog(int port, int analog0, int analog1)
void resetCounter(int port, int counter)
void setDebounceTime(int port,int counter, int msec)

void updateAllInputs()
void requestAllOutputs()

-----
Detailed Description

This class allows, through the QT libraries, the command and control of the Velleman K8055 card or VM110n.
It is derived from the library libK8055 and, as it requires the libusb library.
In the specific request is the libusb 1.0, which allows porting across different operating systems. For the compilation are obviously also need the headers of that library.
Unlike libK8055 is not written in C, but in C + + and, through integration with the QT libraries, allows the use of the mechanism SIGNALS / SLOTS. By exchanging messages through this mechanism it is possible to assign the object to a separate thread QK8055 in total safety thanks to the method moveToThread (QThread *);
There is also direct access methods, but their use in multithreading is strongly discouraged.
The single instance of an object can handle all four cards per single system.
The object QK8055 has an internal timer that allows cyclic monitoring of the tabs and the issuance of the respective signals in case of changes. This timer should be started manually in case you wish to use the cards in this way.

-----
Member Function Documentation
QK8055::QK8055(QObject * parent = 0)
Constructs the main object.
This object can handle one to "maxDevices()" devices.

QK8055::~QK8055()
Destructs the main object.
Also close all opened devices and free memory.

int QK8055::maxDevices()
Return max number of devices that system can handle.

const QList<int> &QK8055::openedDevicesPorts()
Return reference to a QList<int> containing all ports of opened devices.


bool QK8055::readDigitalInput(int port, int channel)
Return status of input channel of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!

int QK8055::readAllDigitalInput(int port)
Return status of inputs as bitmask of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!

int QK8055::readAnalog0(int port)
Return value of analog input 0 of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!

int QK8055::readAnalog1(int port)
Return value of analog input 1 of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!

int QK8055::readCounter0(int port)
Return value of analog counter 0 of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!


int QK8055::readCounter1(int port)
Return value of analog counter 1 of device at port.
Negative value indicate error.
This method can not be used in multithreadig, in case use SIGNALS and SLOTS!

void QK8055::inputChanged() [sIGNAL]
Signal emitted when an input is changed after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::errorK8055(int code) [sIGNAL]
Signal emitted when an error is encontred whith devices.
code is negative value.

void QK8055::errorK8055(QString error) [sIGNAL]
Signal emitted when an error is encontred whith devices.
Error is emitted as human readable description.

void QK8055::digitalChanged(int port, int bitmask) [sIGNAL]
Signal emitted when a digital input of device at port is changed after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::digitalActivated(int port, int channel) [sIGNAL]
Signal emitted when a digital input at channel of device at port is activated after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::digitalUnactivated(int port, int channel) [sIGNAL]
Signal emitted when a digital input at channel of device at port is unactivated after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::analog0Changed(int port, int value) [sIGNAL]
Signal emitted when input analog 0 of device at port change value after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::analog1Changed(int port, int value) [sIGNAL]
Signal emitted when input analog 1 of device at port change value after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::counter0Changed(int port, int value) [sIGNAL]
Signal emitted when counter 0 of device at port change value after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::counter1Changed(int port, int value) [sIGNAL]
Signal emitted when counter 1 of device at port change value after a manual or automatic ( see startTimingLoop(int msec) ) reading.

void QK8055::digitalOutChanged(int port, int bitmask) [sIGNAL]
Signal emitted when a digital output of device at port is changed after a request.

void QK8055::digitalOutActivated(int port, int channel) [sIGNAL]
Signal emitted when a digital output at channel of device at port is activated after a request.

void QK8055::digitalOutUnactivated(int port, int channel) [sIGNAL]
Signal emitted when a digital output at channel of device at port is unactivated after a request.

void QK8055::analogOut0Changed(int port, int value) [sIGNAL]
Signal emitted when output analog 0 of device at port change value after a request.

void QK8055::analogOut1Changed(int port, int value) [sIGNAL]
Signal emitted when output analog 1 of device at port change value after a request.

void QK8055::debounce0Changed(int port, int msec) [sIGNAL]
Signal emitted when debounce time of counter 0 of device at port change value after a request.

void QK8055::debounce1Changed(int port, int msec) [sIGNAL]
Signal emitted when debounce time of counter 1 of device at port change value after a request.

void QK8055::openDevice(int port) [PUBLIC SLOT]
This method try to open device at port. If device exists and could be opened, after opening port of this device is appended at devices list.
See openedDevicesPorts().

void QK8055::closeDevice(int port) [PUBLIC SLOT]
Close device at port and free it for another QK8055 istance or another application.

void QK8055::startTimingLoop(int msec) [PUBLIC SLOT]
Create a QTimer and connect timeout to device reading. Time msec is the interval between checks.
QTimer is istantiated here for multi threading. If you call QK8055::moveToThread(QThread *) method is safe call startTimingLoop only after moveToThread.
In singlethread applications startTimingLoop can used everywere.
If a Timing loop is started before moveToThread stop it whit QK8055::stopTimingLoop() and restart after.

void QK8055::startTimingLoop(int msec) [PUBLIC SLOT]
Stop timing loop and delete instantiated QTimer.
If you call QK8055::moveToThread(QThread *) method is safe call startTimingLoop only after moveToThread.
In singlethread applications startTimingLoop can used everywere.
If a Timing loop is started before moveToThread stop it whit QK8055::stopTimingLoop() and restart after.

void QK8055::setQuickModeOn(bool status=true) [PUBLIC SLOT]
Speed up reading from device. On other side, results may be inaccurate.
By default Quik Mode is disabled.

void QK8055::setQuickModeOff(bool status=true) [PUBLIC SLOT]
By default Quik Mode is disabled.
See QK8055::setQuickModeOn(bool status=true).

void QK8055::setAllDigital(int port, int bitmask) [PUBLIC SLOT]
Set outputs of device at to specified 8bit bitmask additional bits are ignored.

void QK8055::resetAllDigital(int port) [PUBLIC SLOT]
Set outputs of device at port to off.
Equivalent at QK8055::setAllDigital(port,0).

void QK8055::setDigitalOn(int port, int channel, bool status=true) [PUBLIC SLOT]
If status is true activate digital output at channel of board at port, else unactivate it.

void QK8055::setDigitalOff(int port, int channel, bool status=true) [PUBLIC SLOT]
If status is false activate digital output at channel of board at port, else unactivate it.

void QK8055::setAllAnalog(int port, int analog0, int analog1) [PUBLIC SLOT]
Set analog outputs to respective values analog0 and analog1.

void QK8055::resetCounter(int port, int counter) [PUBLIC SLOT]
If counter is 0 reset counter 0, if conter is 1 reset conter 1 of board at port.

void QK8055::setDebounceTime(int port, int counter, int msec) [PUBLIC SLOT]
Set debounce time of counter at msec in millisecods.

void QK8055::updateAllInputs() [PUBLIC SLOT]
In response of this slot QK8055 read devices and emit ALL inputs (also of unchanged inputs) SIGNALS.
Useful for updates.

void QK8055::requestAllOutputs() [PUBLIC SLOT]
In response of this slot QK8055 emit ALL outputs (also of unchanged output) SIGNALS.
Useful for updates.

[Adelino Rossi]

secondo me c'è o un errore di forum o un errore di copia incolla.

possiedo da qualche anno una scheda K8061 superiore per numero di segnali ma stessa tecnica di gestione.

l'ho acquistata in una bancarella della fiera perché cercavo qualcosa come acquisizione dati.

l'ho trovata buona, (a mio parere come rapporto prezzo/pretazioni. un centinaio di euro

vedi link

product

il disco allegato contiene già tutte le librerie e i demo per i principali linguaggi.

personalmente l'ho utilizzata in Visual Basic6 senza problemi.

a mio parere l'unico aspetto di dubbio in un sistema di controllo attivo professionale è l'uso della connessione usb intesa come struttura meccanica dei connettori.

mentre ad esempio ethernet ha una clip di scatto alla chiusura, la connessione usb può essere labile e lenta meccanicamente cosi come ci succede con i dischi rigidi esterni

o altre periferiche. ma questo non dipende dalla scheda in se stessa ma dal sitema universalmente diffuso usb.

[Livio Orsini]

secondo me c'è o un errore di forum o un errore di copia incolla.

Può essere che qualcuno abbia scoperto la ruota senza sapere che è un dispositivo noto da parecchio tempo.

Tra l'altro non capisco perchè un Italiano debba presentare ad altri italiani, su di un forum italiano, un suo lavoro scritto solo in lingua inglese. Non è che il lavoro sia più interessante o migliore se è in inglese.

Modificato: 17 agosto 2013 da Livio Orsini

[Marco Mondin]

Ero completamente consapevole dall'inizio di avere riscritto qualcosa di già esistente, ma non tutti i gusti sono alla menta...

Ho riportato il reference manual in inglese, in quanto il progetto è depositato su un deposito di progetti open source internazionale e sul forum internazionale della Velleman. L'italiano sarebbe poco accetto. Chiedo venia.

È ovvio che i metodi somigliano alle funzioni già presenti su altre librerie, in fondo si tratta della gestione della stessa scheda.

Prima di iniziare ho indagato su tutte le librerie esistenti (Per lo meno quelle che ho trovato su internet).
L'unica con controllo autonomo di eventi fa uso di activeX, cosa la la rende molto poco potrabile (proprio per nulla).

Ho trovato librerie in C e in delphi e ad una di queste mi sono ispirato.

A me interessava una libreria che definisse una classe per istanziare un oggetto autonomo in C++ con gestione di eventi e che fosse possibilmente portabile.
Ho scelto di appoggiarla alle librerie QT in quanto derivando la classe QObject ho potuto fare in modo che QtK8055 ereditasse la gestione del multithreading, la gestione degli eventi come segnali e slots e si potesse integrare con tutte le altre classi derivate da QObject come le varie derivazioni di QWidget e dei QAbstractSocket.

Appoggiandola a libUSB e le librerie QT ho anche avuto la possibilta di creare qualcosa che non fosse vincolato al sistema operativo.
Può essere usata si Windows, Linux, Unix, BSD e MacOS semplicemente ricompilando i sorgenti degli applicativi.
A me interessava che funzionasse su linux, in quanto è una scelta ideale per microPC come i raspberryPI sui quali è impensabile oltre che inutile portarsi dietro tutta l'infrastruttura di Windows.

È vero che grazie a Visual Basic chiunque in poco tempo può scrivere due righe per gestire tale scheda, ma fare funzionare Visual Basic su un PC grosso come una carta di credito da 20€ come un raspberry PI non è una strada praticabile. A me interessava qualcosa in C++ che al contempo fosse sufficientemente leggero.

La k8061 è molto più prestazionale ma è molto più cara e meno usata. Comunque in poche ore potrebbe essere integrata nella stessa libreria.

Non credo di avere riscoperto la ruota, ma semplicemente di averla riadattata per usarla a mio comodo montandoci un mozzo più congeniale a me decidendo poi di condividere con gli altri.

Scusate ancora se sono stato frainteso.

[Livio Orsini]

Non c'è nulla di cui tu debba scusarti.

E' che, come hai scritto tu, non tutti i gusti sono alla menta ed ognuno ha le sue opinioni e le sue preferenze.

E' comunque lodevole l'intenzione di condividere le proprie esperienze con l'auspicio che possano essere di utilità/ispirazione a qualcun altro.

Se hai/avrai altre segnalazioni saranno comunque ben accette e, naturalmente, criticate. Ma le critiche, se espresse in modo civile, sono sempre uno stimolo per migliorarsi.

Modificato: 17 agosto 2013 da Livio Orsini