Buenas,

Estoy realizando un proyecto en Java con el que necesito saber qué USB está siendo usado, me explico:

Estoy programando en un portátil que tiene 3 entradas USB:

• USB 3.0
• USB 2.0
• USB 2.0

Y por otro lado, tengo un escaner de huella dactilar que se conecta por USB.

He estado mirando la librería jUSB pero esta necesita instalar un driver para poder usarla así que la he descartado.
Luego he estado indagando sobre la librería usb4java y he visto sus ejemplos. Copiando y pegando he preparado este pequeño código:

package pruebausb;
 
import org.usb4java.Context;
import org.usb4java.Device;
import org.usb4java.DeviceDescriptor;
import org.usb4java.DeviceList;
import org.usb4java.LibUsb;
import org.usb4java.LibUsbException;
 
public class PruebaUSB {
 
    public static void main(String[] args) {
          // Create the libusb context
        Context context = new Context();
 
        // Initialize the libusb context
        int result = LibUsb.init(context);
        if (result < 0)
            throw new LibUsbException("Unable to initialize libusb", result);
 
        // Read the USB device list
        DeviceList list = new DeviceList();
        result = LibUsb.getDeviceList(context, list);
        if (result < 0)
            throw new LibUsbException("Unable to get device list", result);
 
        try {
            // Iterate over all devices and list them
            for (Device device: list) {
 
                DeviceDescriptor descriptor = new DeviceDescriptor();
                result = LibUsb.getDeviceDescriptor(device, descriptor);
                if (result < 0)
                    throw new LibUsbException("Unable to read device descriptor", result);                
                System.out.println(descriptor.dump());
            }
        } finally {
            // Ensure the allocated device list is freed
            LibUsb.freeDeviceList(list, true);
        }
 
        // Deinitialize the libusb context
        LibUsb.exit(context);
    }
}

Y al ejecutarlo me aparece esto:

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                0.00
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          0
  idVendor            0x1022
  idProduct           0x7809
  bcdDevice             0.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                0.00
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          0
  idVendor            0x1022
  idProduct           0x7807
  bcdDevice             0.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                0.00
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          0
  idVendor            0x1022
  idProduct           0x7807
  bcdDevice             0.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                0.00
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          0
  idVendor            0x1022
  idProduct           0x7808
  bcdDevice             0.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                0.00
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          0
  idVendor            0x1022
  idProduct           0x7808
  bcdDevice             0.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1

Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                2.00
  bDeviceClass           239 Unknown
  bDeviceSubClass          2
  bDeviceProtocol          1
  bMaxPacketSize0         64
  idVendor            0x04f2
  idProduct           0xb3b1
  bcdDevice            57.16
  iManufacturer            3
  iProduct                 1
  iSerial                  2
  bNumConfigurations       1

Por esto deduzco que usb4java no soporta USB 3.0 (no se si estoy en lo cierto), pero lo que me confunde es que deberían aparecer bcdUSB con valor 2.00 (que creo que es la versión del puerto USB si estoy en lo cierto).

Necesito saber si hay alguna forma de darle a cada puerto USB un nombre estilo COM1, COM2, etc. para distinguir cuándo conecto el escaner de huella dactilar a un USB u otro.

Buenas,

Estoy realizando un proyecto en Java y necesito comprar un detector de huellas dactilares. Me decidido a comprar el UrU 4500 de DigitalPerson pero cuando he comenzado a buscar dónde comprarlo comparando precios me he encontrado con que existe un modelo llamado UrU 5000 que es mas fácil de adquirir.

¿Alguien sabe las diferencias entre ambos modelos?

Buenas, estoy intentando usar la función remove_if para eliminar espacios en blanco de una cadena de caracteres de bajo nivel. He aquí la función que he diseñado:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <string>
using namespace std;
 
class EsBlanco {
public:
  bool operator() (const char& c) const { return std::isspace(c); }
};
 
int main() {
  string s = "4539 4512 0398 7356";
  char *letras = new char [s.length() + 1];
  strcpy (letras, s.c_str());
 
  char * inicio = letras;
  char * fin = letras + s.length();
 
  fin = std::remove_if(inicio,fin,EsBlanco());
 
  for (char * p = inicio; p != fin; ++p)
     cout  << *p;
  return 0;
}

El problema que ocurre es que elimina los 3 espacios en blanco que hay en el string pero el numero resultante es: 4539451203987356356

Creo que se vuelven a repetir los 3 últimos números porque se eliminaron los otros 3 huecos de los espacios. Alguien podría guiarme para encontrar una solución

Buenas estoy escribiendo la siguiente funcion

#include <iostream>
#include <cstring>
#include <functional>
#include <algorithm>
 
using namespace std;
 
class EsDigito {
public:
bool operator() (const char& c) const { return isdigit(c); }
};
 
int main() {
unary_negate<bool> EsAlfabetico (EsDigito);
 
char letras2[] = " 452485A56321";
inicio = letras;
fin = letras + sizeof(letras)/sizeof(char);
 
 if (find_if(inicio,fin,EsAlfabetico()))
 
   cout << "Alfabetico" << endl;
 
  return 0;
 
}
 

Cuando compilo me sale el siguiente error:

prueba.cpp:35:39: error: faltan argumentos para la función ‘std::unary_negate<bool> EsAlfabetico(EsDigito)’
prueba.cpp:30:22: nota: se declara aquí

Alguien me puede explicar el por qué

 
 
 

Buenas,

Estoy realizando una clase Tarjeta, la cual tiene el siguiente constructor:

#include "tarjeta.h"
#include "usuario.h"
 
using namespace std;
 
Tarjeta::Tarjeta (const Numero& numero, const Usuario &user, const Fecha& caducidad) : numero_(numero), user_(&user), caducidad_(caducidad) {
  Fecha f_actual;
  titular_ = user.nombre() + " " + user.apellidos();
 
  if (caducidad_ < f_actual)
    throw(Tarjeta::Caducada(caducidad_));
  //(&user).es_titular_de(*this);
} 
 

Por otro lado, aquí tenemos la cabecera tarjeta.h

#ifndef _TARJETA_H_
#define _TARJETA_H_
 
#include "fecha.h"
#include "cadena.h"
#include "numero.h"
 
class Usuario;
 
class Tarjeta {
 public:
  class Caducada {
  public:
    Caducada (const Fecha& f) : fecha_(f) {}
    Fecha cuando() const { return fecha_; }
  private:
    Fecha fecha_;
  };
 
  Tarjeta (const Numero&, const Usuario&, const Fecha&);
 
  Numero numero() const { return numero_; }
  Fecha caducidad() const { return caducidad_; }
  Cadena titular_facial() const { return titular_; }
  const Usuario* titular() const { return user_; }
  void anula_titular();
 
  friend std::ostream& operator << (std::ostream&, const Tarjeta&);
 private:
  Numero numero_; //Numero de identificacion de la tarjeta
  const Usuario * const user_; //Puntero constante al usuario dueño
  Fecha caducidad_; //Fecha de caducidad
  Cadena titular_; // Nombre y apellidos del dueño
 
  Tarjeta (const Tarjeta&);//Deshabilitamos copia de una tarjeta
};
#endif

Y por otro lado, los archivos de USUARIO:

#ifndef _USUARIO_H_
#define _USUARIO_H_
 
#include "cadena.h"
#include "clave.h"
#include "articulo.h"
#include "tarjeta.h"
#include "numero.h"
 
#include <sstream> //ostringstream
#include <map>
#include <set>
using std::map;
using std::set;
 
class Tarjeta;
 
class Usuario {
 public:
  //CONSTRUCTOR Y DESTRUCTOR
  Usuario (const Cadena&, const Cadena&, const Cadena&, const Cadena&, const char*);
  //~Usuario();
 
  class Id_duplicado {
  public:
    Id_duplicado (const Cadena& id) : id_duplicado(id) {}
    const Cadena idd() { return id_duplicado; }
  private:
    const Cadena id_duplicado;
  };
  //FUNCIONES OBSERVADORAS
  Cadena id() const { return identificador_; }
  Cadena nombre() const { return nombre_; }
  Cadena apellidos() const { return apellidos_; }
  Cadena direccion() const { return direccion_; }
  Cadena password() const { return password_.clave(); }
 
  //FUNCIONES CON TARJETAS
  typedef map<Numero, Tarjeta*> Tarjetas;
  void es_titular_de(Tarjeta&);
  /*
  
  void no_es_titular_de(Tarjeta&);
  const Tarjetas& tarjetas() const;
  */
 
  //FUNCIONES CON LOS ARTICULOS
  typedef map<Articulo*, unsigned> Articulos;
  void compra(Articulo&, unsigned);
  const Articulos& compra() const { return articulos_; } 
  size_t n_articulos() const { return articulos_.size(); }
 
  //SOBRECARGA OPERADOR 
  friend std::ostream& operator << (std::ostream&, const Usuario&); 
 
 private:
  Cadena identificador_;
  Cadena nombre_;
  Cadena apellidos_;
  Cadena direccion_; 
  Clave password_;
  /*  
      Tarjetas tarjetas_;*/
  Articulos articulos_;
 
  static set<Cadena> identificadores;
  bool IdValido() const throw(Usuario::Id_duplicado);
  Usuario (const Usuario&); //Deshabilitamos la copia de un usuario
};
 
void mostrar_carro(std::ostringstream&, const Usuario&);
//inline const Tarjetas& tarjetas() const { return tarjetas_; }
 
#endif

El problema es que cada vez que se crea una tarjeta, su constructor, debe asociar al usuario dueño la existencia de dicha tarjeta con la función void es_titular_de(Tarjeta&);

Pero no sé hacerlo ya que me sale un error diciendo:

pasar ‘const Usuario’ como el argumento ‘this’ de ‘void Usuario::es_titular_de(Tarjeta&)’ descarta a los calificadores