Como enviar e receber dados de uma conexão USB usando C++ no Linux

Neste tutorial, vamos aprender como criar um código em C++ no Linux para enviar e receber dados de uma conexão USB.

Passo 1: Instale as ferramentas de desenvolvimento necessárias

Para começar, você precisa instalar as ferramentas de desenvolvimento necessárias, como o compilador GCC e as bibliotecas de desenvolvimento do Linux.

Passo 2: Descubra a porta USB a ser usada

Antes de começar a enviar e receber dados pela conexão USB, você precisa descobrir qual porta USB está sendo usada pelo dispositivo. Para isso, você pode usar o comando “dmesg” no terminal do Linux para listar os dispositivos USB conectados.

Passo 3: Crie o código em C++

Agora, vamos criar o código em C++ para enviar e receber dados pela conexão USB. O código deve incluir a biblioteca “libusb” para trabalhar com dispositivos USB no Linux.

#include <iostream>
#include <libusb-1.0/libusb.h>

#define VENDOR_ID 0x1234 // Substituir pelo ID do fornecedor do dispositivo USB
#define PRODUCT_ID 0x5678 // Substituir pelo ID do produto do dispositivo USB
#define OUT_ENDPOINT 0x01 // Substituir pelo endpoint de saída do dispositivo USB
#define IN_ENDPOINT 0x82 // Substituir pelo endpoint de entrada do dispositivo USB

int main() {
    libusb_device_handle* dev_handle;
    int r;
    // Inicializa a biblioteca libusb
    r = libusb_init(NULL);
    if (r < 0) {
        std::cerr << "Erro ao inicializar a biblioteca libusb: " << libusb_error_name(r) << std::endl;
        return 1;
    }
    // Abre o dispositivo USB
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);
    if (dev_handle == NULL) {
        std::cerr << "Erro ao abrir o dispositivo USB" << std::endl;
        return 1;
    }
    // Configura o dispositivo USB
    r = libusb_set_configuration(dev_handle, 1);
    if (r < 0) {
        std::cerr << "Erro ao configurar o dispositivo USB: " << libusb_error_name(r) << std::endl;
        libusb_close(dev_handle);
        return 1;
    }
    // Reivindica a interface do dispositivo USB
    r = libusb_claim_interface(dev_handle, 0);
    if (r < 0) {
        std::cerr << "Erro ao reivindicar a interface do dispositivo USB: " << libusb_error_name(r) << std::endl;
        libusb_close(dev_handle);
        return 1;
    }
    // Envia dados para o dispositivo USB
    unsigned char data_out[64] = {0x01, 0x02, 0x03, 0x04};
    int bytes_sent;
    r = libusb_bulk_transfer(dev_handle, OUT_ENDPOINT, data_out, sizeof(data_out), &bytes_sent, 0);
    if (r < 0) {
        std::cerr << "Erro ao enviar dados para o dispositivo USB: " << libusb_error_name(r) << std::endl;
        libusb_release_interface(dev_handle, 0);
        libusb_close(dev_handle);
        return 1;
    }
    // Recebe dados do dispositivo USB
    unsigned char data_in[64];
    int bytes_received;
    r = libusb_bulk_transfer(dev_handle, IN_ENDPOINT, data_in, sizeof(data_in), &bytes_received, 0);
    if (r < 0) {
        std::cerr << "Erro ao receber dados do dispositivo USB: " << libusb_error_name(r) << std::endl;
        libusb_release_interface(dev_handle, 0);
        libusb_close(dev_handle);
        return 1;
    }
    // Imprime os dados recebidos
    std::cout << "Dados recebidos: ";
    for (int i = 0; i < bytes_received; i++) {
        std::cout << std::hex << (int)data_in[i] << " ";
    }
    std::cout << std::endl;
    // Libera a interface do dispositivo USB e fecha a conexão
    libusb_release_interface(dev_handle, 0);
    libusb_close(dev_handle);
    // Finaliza a biblioteca libusb
    libusb_exit(NULL);
    return 0;
}

O código acima utiliza a biblioteca libusb para enviar e receber dados pela porta USB em um sistema Linux. Na linha 6, definimos o ID do fornecedor e do produto do dispositivo USB que queremos comunicar. Na linha 7 e 8, definimos os endpoints de entrada e saída do dispositivo USB, respectivamente.

Na função main(), iniciamos a biblioteca libusb (linha 14), abrimos o dispositivo USB (linha 19), configuramos o dispositivo (linha 24) e reivindicamos a interface do dispositivo (linha 29).

Em seguida, enviamos dados para o dispositivo USB utilizando a função libusb_bulk_transfer() na linha 37. Esta função envia os dados no buffer data_out para o endpoint de saída definido na linha 8. A quantidade de bytes enviados é armazenada na variável bytes_sent.

Depois, recebemos dados do dispositivo USB utilizando a função libusb_bulk_transfer() na linha 46. Esta função recebe os dados do endpoint de entrada definido na linha 7 e armazena os dados recebidos no buffer data_in. A quantidade de bytes recebidos é armazenada na variável bytes_received.

Por fim, liberamos a interface do dispositivo USB e fechamos a conexão com o dispositivo (linha 60) e finalizamos a biblioteca libusb (linha 63).

É importante lembrar que o código acima é apenas um exemplo genérico de como enviar e receber dados pela porta USB em um sistema Linux. Para que este código funcione com um dispositivo USB específico, é necessário modificar os valores de VENDOR_ID, PRODUCT_ID, OUT_ENDPOINT e IN_ENDPOINT de acordo com as especificações do dispositivo.

Passo 4: Compile o código

Com o código em C++ criado, você pode compilá-lo usando o GCC. Certifique-se de incluir a biblioteca “libusb” ao compilar o código.

$ g++ -o usb_communication usb_communication.cpp -lusb-1.0

Passo 5: Execute o código

Por fim, execute o código compilado para enviar e receber dados pela conexão USB.

$ ./usb_communication

Com isso, você aprendeu como enviar e receber dados de uma conexão USB usando C++ no Linux. Lembre-se de que as portas e endpoints podem variar de acordo com o dispositivo USB que você está usando.