UNIVERSITE D’ANTANANARIVO

------------------------------------
INSTITUT D’ENSEIGNEMENT SUPERIEUR D’ANTSIRABE-VAKINANKARATRA
------------------------------------
DOMAINE SCIENCES DE L’INGENIEUR

Rapport : COMMANDE DE SYSTEME PAR ORDINATEUR

MENTION ELECTRONIQUE

Parcours : ELECTRONIQUE et INSTRUMENTATION

ELECTRONIQUE et COMMANDE

GROUPE CINQ

Présenté par :
ANDRIARIMALALA Lantomahafaly Joela Miharivony
FANEVANIAINA Manovosoa
RANDRIAMANANTSOA Roméo Franick
HERINOMENJANAHARY Sidonie Valerie

Date de rendu : vendredi 26 Mai 2023

 UNIVERSITE D’ANTANANARIVO
------------------------------------
INSTITUT D’ENSEIGNEMENT SUPERIEUR D’ANTSIRABE-VAKINANKARATRA
------------------------------------
DOMAINE SCIENCES DE L’INGENIEUR

Rapport : COMMANDE DE SYSTEME PAR ORDINATEUR

MENTION ELECTRONIQUE

Parcours : ELECTRONIQUE et INSTRUMENTATION

ELECTRONIQUE et COMMANDE

Présenté par :
ANDRIARIMALALA Lantomahafaly Joela Miharivony
FANEVANIAINA Manovosoa
RANDRIAMANANTSOA Roméo Franick
HERINOMENJANAHARY Sidonie Valerie

Chef Mention : Docteur RATIANARIVO Paul Ezekel

Enseignant : Dr Sedera
PORT PARALLELE
Exemple 1 : Contrôler des LED
#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

unsigned long delayCount = milliseconds * (1193180 / 1000);
asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char data = 0x01; // Données pour allumer les LED
unsigned int i;

// Initialisation du port parallèle en mode de sortie

outp(BASE + 2, 0x00);

while (1) {
// Écriture des données sur le port parallèle
outp(BASE, data);

// Attente de 500 ms
 delay(500);

// Décalage des données pour allumer la prochaine LED

data <<= 1;
if (data == 0) {
data = 0x01;
}
}

return 0;
}

Ce code utilise l'adresse de base 0x378 pour accéder au port parallèle. On peut modifier cette
valeur selon l'adresse du port parallèle si nécessaire.

Il faut assurer d'avoir les bibliothèques appropriées incluses (stdio.h, conio.h, dos.h) pour
pouvoir utiliser les fonctions nécessaires. Ce code est spécifique à la plate-forme
DOS/Windows.

Exemple 2 : Mesurer la température

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

 unsigned long delayCount = milliseconds * (1193180 / 1000);
asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char command = 0x80; // Commande pour démarrer la conversion
unsigned char data;
float temperature;

// Initialisation du port parallèle en mode d'entrée

outp(BASE + 2, 0xFF);

// Écriture de la commande sur le port parallèle pour démarrer la conversion

outp(BASE, command);

// Attente de la fin de la conversion (valeur arbitraire, ajustez si nécessaire)

delay(100);

// Lecture des données de température depuis le port parallèle

data = inp(BASE);

// Conversion des données en degrés Celsius

temperature = (float)data * 0.48876;

// Affichage de la température en degrés Celsius

 printf("Température : %.2f °C\n", temperature);

return 0;
}

Contrôler un relais

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

unsigned long delayCount = milliseconds * (1193180 / 1000);
asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char relayOn = 0x01; // Données pour activer le relais
unsigned char relayOff = 0x00; // Données pour désactiver le relais

// Initialisation du port parallèle en mode de sortie

outp(BASE + 2, 0x00);
 // Activation du relais
outp(BASE, relayOn);

// Attente d'une seconde

delay(1000);

// Désactivation du relais
outp(BASE, relayOff);

return 0;
}

Ce code initialise le port parallèle en mode de sortie, puis écrit les données 0x01 sur le port
parallèle pour activer le relais. Ensuite, il attend pendant 1 seconde à l'aide de la fonction
delay, puis écrit les données 0x00 sur le port parallèle pour désactiver le relais.

Contrôler un moteur pas à pas

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

 unsigned long delayCount = milliseconds * (1193180 / 1000);
asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char stepSequence[] = {0x01, 0x02, 0x04, 0x08};
int numSteps = sizeof(stepSequence) / sizeof(stepSequence[0]);
int i;

// Initialisation du port parallèle en mode de sortie

outp(BASE + 2, 0x00);

// Boucle pour effectuer une séquence de pas

while (1) {
for (i = 0; i < numSteps; i++) {
// Écriture de la séquence de pas sur le port parallèle
outp(BASE, stepSequence[i]);

// Attente de 50 ms
delay(50);
}
}

return 0;
}
Ce code initialise le port parallèle en mode de sortie, puis utilise un tableau stepSequence pour
définir la séquence de pas du moteur pas à pas. Il boucle en boucle infinie et, à chaque itération,
écrit une valeur de la séquence de pas sur le port parallèle, attend 50 ms à l'aide de la fonction
delay, puis passe à la valeur suivante dans la séquence.

Contrôler un actionneur pneumatique

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

unsigned long delayCount = milliseconds * (1193180 / 1000);
asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char actuatorOn = 0x01; // Données pour activer l'actionneur
unsigned char actuatorOff = 0x00; // Données pour désactiver l'actionneur

// Initialisation du port parallèle en mode de sortie

outp(BASE + 2, 0x00);

// Activation de l'actionneur
 outp(BASE, actuatorOn);

// Attente d'une seconde

delay(1000);

// Désactivation de l'actionneur
outp(BASE, actuatorOff);

return 0;
}

Ce code initialise le port parallèle en mode de sortie, puis écrit les données 0x01 sur le port
parallèle pour activer l'actionneur pneumatique. Ensuite, il attend pendant 1 seconde à l'aide
de la fonction delay, puis écrit les données 0x00 sur le port parallèle pour désactiver
l'actionneur. L'utilisation du port parallèle pour contrôler un actionneur pneumatique peut
nécessiter des composants supplémentaires, tels que des relais, des amplificateurs de
puissance, des circuits de contrôle et de protection, pour assurer un fonctionnement sûr et
fiable.

Contrôler un moteur pas à pas pour une CNC

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define BASE 0x378 // Adresse de base du port parallèle

void delay(unsigned int milliseconds) {

unsigned long delayCount = milliseconds * (1193180 / 1000);
 asm volatile("movl %0, %%ecx; 1: loop 1b; dec %%ecx"
: : "g"(delayCount) : "ecx");
}

int main() {
unsigned char stepSequence[] = {0x01, 0x02, 0x04, 0x08};
int numSteps = sizeof(stepSequence) / sizeof(stepSequence[0]);
int i;

// Initialisation du port parallèle en mode de sortie

outp(BASE + 2, 0x00);

// Boucle pour effectuer une séquence de pas

while (1) {
for (i = 0; i < numSteps; i++) {
// Écriture de la séquence de pas sur le port parallèle
outp(BASE, stepSequence[i]);

// Attente de 2 ms
delay(2);
}
}

return 0;
}
Ce code initialise le port parallèle en mode de sortie, puis utilise un tableau stepSequence pour
définir la séquence de pas du moteur pas à pas. Il boucle en boucle infinie et, à chaque itération,
écrit une valeur de la séquence de pas sur le port parallèle, attend 2 ms à l'aide de la fonction
delay, puis passe à la valeur suivante dans la séquence.

Introduction aux ports série

Lecture de données de capteurs

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <termios.h>

#define SERIAL_PORT "/dev/ttyUSB0" // Chemin du port série

int main() {

int serialPort;

char buffer[256];

// Ouverture du port série en lecture seule

serialPort = open(SERIAL_PORT, O_RDONLY);

if (serialPort == -1) {

perror("Erreur lors de l'ouverture du port série");

exit(EXIT_FAILURE);

// Configuration des paramètres du port série

struct termios serialOptions;

tcgetattr(serialPort, &serialOptions);
 cfsetispeed(&serialOptions, B9600); // Vitesse de transmission (9600 bauds)

serialOptions.c_cflag &= ~PARENB; // Pas de parité

serialOptions.c_cflag &= ~CSTOPB; // 1 bit d'arrêt

serialOptions.c_cflag &= ~CSIZE;

serialOptions.c_cflag |= CS8; // 8 bits de données

tcsetattr(serialPort, TCSANOW, &serialOptions);

// Lecture des données du port série

ssize_t bytesRead;

while (1) {

bytesRead = read(serialPort, buffer, sizeof(buffer));

if (bytesRead > 0) {

// Traitement des données lues

// ...

printf("Données lues : %.*s\n", (int)bytesRead, buffer);

// Fermeture du port série

close(serialPort);

return 0;

On utilise les fonctions système open(), read() et close() pour ouvrir, lire et fermer le port
série respectivement. Il faut spécifier correctement le chemin du port série dans la constante
SERIAL_PORT. Le code configure également les paramètres du port série, tels que la vitesse de
transmission, le nombre de bits de données, etc., en utilisant la structure termios. Dans la
boucle principale, on utilise la fonction read() pour lire les données du port série dans le
tampon buffer. Si des données sont lues (bytesRead > 0).
Envoi de commandes à des équipements

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <termios.h>

#define SERIAL_PORT "/dev/ttyUSB0" // Chemin du port série

int main() {

int serialPort;

char command[] = "AT\r\n"; // Commande à envoyer

// Ouverture du port série en écriture seule

serialPort = open(SERIAL_PORT, O_WRONLY);

if (serialPort == -1) {

perror("Erreur lors de l'ouverture du port série");

exit(EXIT_FAILURE);

// Configuration des paramètres du port série

struct termios serialOptions;

tcgetattr(serialPort, &serialOptions);

cfsetispeed(&serialOptions, B9600); // Vitesse de transmission (9600 bauds)

serialOptions.c_cflag &= ~PARENB; // Pas de parité

serialOptions.c_cflag &= ~CSTOPB; // 1 bit d'arrêt

serialOptions.c_cflag &= ~CSIZE;

serialOptions.c_cflag |= CS8; // 8 bits de données

tcsetattr(serialPort, TCSANOW, &serialOptions);

 // Envoi de la commande au port série

ssize_t bytesWritten = write(serialPort, command, sizeof(command) - 1);

if (bytesWritten == -1) {

perror("Erreur lors de l'envoi de la commande");

exit(EXIT_FAILURE);

// Attente de la réponse de l'équipement (facultatif)

sleep(1);

// Fermeture du port série

close(serialPort);

return 0;

On utilise la fonction système open() pour ouvrir le port série en mode écriture seule. On
doit spécifier correctement le chemin du port série dans la constante SERIAL_PORT. Le code
configure également les paramètres du port série, tels que la vitesse de transmission et le
nombre de bits de données, en utilisant la structure termios.

Ensuite, on utilise la fonction write() pour envoyer la commande spécifiée (command) sur le
port série. La taille de la commande est déduite en utilisant sizeof(command) - 1 pour
exclure le caractère nul de fin de chaîne.

Commande de moteurs pas à pas

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <termios.h>
#define SERIAL_PORT "/dev/ttyUSB0" // Chemin du port série

int main() {

int serialPort;

char command[] = "M1P1000\r\n"; // Commande de mouvement pour le moteur pas à pas

// Ouverture du port série en écriture seule

serialPort = open(SERIAL_PORT, O_WRONLY);

if (serialPort == -1) {

perror("Erreur lors de l'ouverture du port série");

exit(EXIT_FAILURE);

// Configuration des paramètres du port série

struct termios serialOptions;

tcgetattr(serialPort, &serialOptions);

cfsetispeed(&serialOptions, B9600); // Vitesse de transmission (9600 bauds)

serialOptions.c_cflag &= ~PARENB; // Pas de parité

serialOptions.c_cflag &= ~CSTOPB; // 1 bit d'arrêt

serialOptions.c_cflag &= ~CSIZE;

serialOptions.c_cflag |= CS8; // 8 bits de données

tcsetattr(serialPort, TCSANOW, &serialOptions);

// Envoi de la commande de mouvement au port série

ssize_t bytesWritten = write(serialPort, command, sizeof(command) - 1);

if (bytesWritten == -1) {

perror("Erreur lors de l'envoi de la commande de mouvement");

exit(EXIT_FAILURE);

// Fermeture du port série

 close(serialPort);

return 0;

On utilise la fonction système open() pour ouvrir le port série en mode écriture seule. Il faut
spécifier correctement le chemin du port série dans la constante SERIAL_PORT. Le code
configure également les paramètres du port série, tels que la vitesse de transmission et le
nombre de bits de données, en utilisant la structure termios. On use la fonction write()
pour envoyer la commande de mouvement spécifique (command) au moteur pas à pas via le
port série. La taille de la commande est déduite en utilisant sizeof(command) - 1 pour
exclure le caractère nul de fin de chaîne.

Contrôle d'un robot

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>

#define SERIAL_PORT "/dev/ttyUSB0" // Chemin du port série

int main() {
int serialPort;
char command[] = "MOVE_FORWARD\r\n"; // Commande de
déplacement pour le robot
char buffer[256];
 // Ouverture du port série en lecture/écriture
serialPort = open(SERIAL_PORT, O_RDWR);
if (serialPort == -1) {
perror("Erreur lors de l'ouverture du port série");
exit(EXIT_FAILURE);
}

// Configuration des paramètres du port série

struct termios serialOptions;
tcgetattr(serialPort, &serialOptions);
cfsetispeed(&serialOptions, B9600); // Vitesse de transmission
(9600 bauds)
serialOptions.c_cflag &= ~PARENB; // Pas de parité
serialOptions.c_cflag &= ~CSTOPB; // 1 bit d'arrêt
serialOptions.c_cflag &= ~CSIZE;
serialOptions.c_cflag |= CS8; // 8 bits de données
tcsetattr(serialPort, TCSANOW, &serialOptions);

// Envoi de la commande de déplacement au robot

ssize_t bytesWritten = write(serialPort, command,
sizeof(command) - 1);
if (bytesWritten == -1) {
perror("Erreur lors de l'envoi de la commande de
déplacement");
 exit(EXIT_FAILURE);
}

// Attente de la réponse du robot

sleep(1);

// Lecture des données de retour du robot

ssize_t bytesRead = read(serialPort, buffer, sizeof(buffer));
if (bytesRead > 0) {
// Traitement des données de retour
// ...
printf("Données de retour : %.*s\n", (int)bytesRead, buffer);
}

// Fermeture du port série

close(serialPort);

return 0;
}

Port USB
ouvre un port USB FTDI à une vitesse de 9600 bauds
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ftdi.h>

int main() {
struct ftdi_context ftdi;
int ret;

// Initialisation de la structure ftdi_context

ftdi_init(&ftdi);

// Ouverture du port USB FTDI

ret = ftdi_usb_open(&ftdi, 0x0403, 0x6001);
if (ret < 0) {
fprintf(stderr, "Erreur lors de l'ouverture du port USB FTDI : %s\
n", ftdi_get_error_string(&ftdi));
exit(EXIT_FAILURE);
}

// Configuration de la vitesse de transmission

ret = ftdi_set_baudrate(&ftdi, 9600);
if (ret < 0) {
 fprintf(stderr, "Erreur lors de la configuration de la vitesse de
transmission : %s\n", ftdi_get_error_string(&ftdi));
ftdi_usb_close(&ftdi);
ftdi_deinit(&ftdi);
exit(EXIT_FAILURE);
}

// Envoi de la commande de configuration

unsigned char command[] = {0x01}; // Commande pour configurer
le module en mode 1
ret = ftdi_write_data(&ftdi, command, sizeof(command));
if (ret < 0) {
fprintf(stderr, "Erreur lors de l'envoi de la commande de
configuration : %s\n", ftdi_get_error_string(&ftdi));
ftdi_usb_close(&ftdi);
ftdi_deinit(&ftdi);
exit(EXIT_FAILURE);
}

// Lecture de la réponse du module

unsigned char response[256];
ret = ftdi_read_data(&ftdi, response, sizeof(response));
if (ret < 0) {
fprintf(stderr, "Erreur lors de la lecture de la réponse : %s\n",
ftdi_get_error_string(&ftdi));
 ftdi_usb_close(&ftdi);
ftdi_deinit(&ftdi);
exit(EXIT_FAILURE);
}

// Affichage de la réponse
printf("Réponse : ");
for (int i = 0; i < ret; i++) {
printf("%02X ", response[i]);
}
printf("\n");

// Fermeture du port USB FTDI

ftdi_usb_close(&ftdi);

// Libération des ressources

ftdi_deinit(&ftdi);

return 0;
}

On utilise la bibliothèque FTDI (libftdi) pour communiquer avec le port USB FTDI. Il faut
installer la bibliothèque libftdi et d'inclure le fichier d'en-tête ftdi.h dans votre projet. La
fonction ftdi_usb_open() est utilisée pour ouvrir le port USB FTDI en spécifiant les identifiants
du fournisseur (0x0403) et du produit (0x6001) correspondant à votre module FTDI. Assurez-
vous de mettre à jour ces identifiants en fonction de votre périphérique.
Contrôle d'un servomoteur à l'aide d'un port USB

#include <stdio.h>

#include <stdlib.h>

#include <libusb-1.0/libusb.h>

#define VENDOR_ID 0x1234 // ID du fournisseur du servomoteur

#define PRODUCT_ID 0x5678 // ID du produit du servomoteur

#define ENDPOINT_OUT 0x01 // Endpoint de sortie pour envoyer des commandes

int main() {

libusb_context *ctx = NULL;

libusb_device_handle *dev_handle = NULL;

int ret;

// Initialisation de la bibliothèque libusb

ret = libusb_init(&ctx);

if (ret < 0) {

fprintf(stderr, "Erreur lors de l'initialisation de libusb\n");

return ret;

// Ouverture du périphérique USB

dev_handle = libusb_open_device_with_vid_pid(ctx, VENDOR_ID, PRODUCT_ID);

if (dev_handle == NULL) {

fprintf(stderr, "Impossible d'ouvrir le périphérique USB\n");

libusb_exit(ctx);

return -1;
 }

// Envoi d'une commande au servomoteur

unsigned char command[] = {0x01}; // Commande spécifique à envoyer

int bytes_sent;

ret = libusb_bulk_transfer(dev_handle, ENDPOINT_OUT, command, sizeof(command),

&bytes_sent, 1000);

if (ret == 0) {

printf("Commande envoyée avec succès\n");

} else {

fprintf(stderr, "Erreur lors de l'envoi de la commande : %s\n", libusb_error_name(ret));

// Fermeture du périphérique USB

libusb_close(dev_handle);

// Fermeture de la bibliothèque libusb

libusb_exit(ctx);

return 0;

On utilise la bibliothèque libusb pour gérer la communication USB. Et on doit installer la

bibliothèque libusb et d'inclure le fichier d'en-tête libusb.h dans votre projet. Il faut
remplacer les valeurs VENDOR_ID et PRODUCT_ID par les identifiants du fournisseur et du
produit spécifiques à votre servomoteur. Ces identifiants permettent à libusb de localiser et
d'ouvrir le périphérique USB correspondant. Ensuite, nous utilisons la fonction
libusb_bulk_transfer() pour envoyer la commande spécifique (command) au servomoteur
via le port USB. La taille de la commande est spécifiée avec sizeof(command). Le
paramètre ENDPOINT_OUT indique l'endpoint de sortie à utiliser pour l'envoi des données.
un programme en langage C qui affiche un carré rouge de 100x100 pixels au
centre de l'écran VGA

#include <SDL2/SDL.h>

#define SCREEN_WIDTH 800

#define SCREEN_HEIGHT 600

#define SQUARE_SIZE 100

int main() {

SDL_Window* window = NULL;

SDL_Renderer* renderer = NULL;

// Initialisation de SDL

if (SDL_Init(SDL_INIT_VIDEO) < 0) {

printf("Erreur lors de l'initialisation de SDL : %s\n", SDL_GetError());

return -1;

// Création de la fenêtre

window = SDL_CreateWindow("Carré Rouge", SDL_WINDOWPOS_UNDEFINED,

SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);

if (window == NULL) {

printf("Erreur lors de la création de la fenêtre : %s\n", SDL_GetError());

SDL_Quit();

return -1;

// Création du renderer

renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

if (renderer == NULL) {
 printf("Erreur lors de la création du renderer : %s\n", SDL_GetError());

SDL_DestroyWindow(window);

SDL_Quit();

return -1;

// Effacement de l'écran avec une couleur noire

SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);

SDL_RenderClear(renderer);

// Dessin du carré rouge

SDL_Rect squareRect;

squareRect.x = (SCREEN_WIDTH - SQUARE_SIZE) / 2;

squareRect.y = (SCREEN_HEIGHT - SQUARE_SIZE) / 2;

squareRect.w = SQUARE_SIZE;

squareRect.h = SQUARE_SIZE;

SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);

SDL_RenderFillRect(renderer, &squareRect);

// Affichage du rendu à l'écran

SDL_RenderPresent(renderer);

// Attente d'un événement de fermeture de la fenêtre

SDL_Event event;

int quit = 0;

while (!quit) {

while (SDL_PollEvent(&event) != 0) {

if (event.type == SDL_QUIT) {

quit = 1;

}
 }

// Libération des ressources

SDL_DestroyRenderer(renderer);

SDL_DestroyWindow(window);

SDL_Quit();

return 0;

C’est tellement utile d’installer la bibliothèque SDL et d'inclure le fichier d'en-tête

SDL2/SDL.h dans votre projet. Ce programme crée une fenêtre SDL de taille SCREEN_WIDTH
x SCREEN_HEIGHT pixels et dessine un carré rouge de taille SQUARE_SIZE au centre de la
fenêtre. La couleur rouge est spécifiée avec les valeurs 255, 0, 0 pour les composantes
RVB. Le programme reste en boucle jusqu'à ce qu'un événement de fermeture de la fenêtre
soit détecté, puis il libère les ressources utilisées par SDL

un programme en C pour lire la valeur de la température à partir du port USB

et l'afficher sur l'écran de l'ordinateur.

#include <stdio.h>

#include <stdlib.h>

#include <libusb-1.0/libusb.h>

#define VENDOR_ID 0x1234 // ID du fournisseur du capteur de température

#define PRODUCT_ID 0x5678 // ID du produit du capteur de température

#define ENDPOINT_IN 0x81 // Endpoint d'entrée pour recevoir les données

int main() {
 libusb_context *ctx = NULL;

libusb_device_handle *dev_handle = NULL;

int ret;

// Initialisation de la bibliothèque libusb

ret = libusb_init(&ctx);

if (ret < 0) {

fprintf(stderr, "Erreur lors de l'initialisation de libusb\n");

return ret;

// Ouverture du périphérique USB

dev_handle = libusb_open_device_with_vid_pid(ctx, VENDOR_ID, PRODUCT_ID);

if (dev_handle == NULL) {

fprintf(stderr, "Impossible d'ouvrir le périphérique USB\n");

libusb_exit(ctx);

return -1;

// Lecture de la valeur de la température

unsigned char buffer[2];

int bytes_received;

ret = libusb_bulk_transfer(dev_handle, ENDPOINT_IN, buffer, sizeof(buffer), &bytes_received,

1000);

if (ret == 0) {

// Interprétation des données reçues et affichage de la température

unsigned short temperature = (buffer[1] << 8) | buffer[0];

printf("Température : %d degrés Celsius\n", temperature);

} else {

fprintf(stderr, "Erreur lors de la lecture de la température : %s\n", libusb_error_name(ret));

}
 // Fermeture du périphérique USB

libusb_close(dev_handle);

// Fermeture de la bibliothèque libusb

libusb_exit(ctx);

return 0;

On utilise la bibliothèque libusb pour gérer la communication USB. Il faut installer la

bibliothèque libusb et inclure le fichier d'en-tête libusb.h dans votre projet. et remplacer
les valeurs VENDOR_ID et PRODUCT_ID par les identifiants du fournisseur et du produit
spécifiques à votre capteur de température. Ces identifiants permettent à libusb de localiser
et d'ouvrir le périphérique USB correspondant. Ensuite, on utilise la fonction
libusb_bulk_transfer() pour recevoir les données de température