Cette page explique comment lire et écrire des tableaux d'octets à l'aide de la bibliothèque Serialib. La bibliothèque Serialib est une bibliothèque multiplateforme écrite en C++.
La bibliothèque a été testée sous Windows et Linux. Ce projet a été développé avec Qt Creator et se compile avec succès avec :
int serialib::writeBytes(const void *Buffer, const unsigned int NbBytes)
La classe Serialib a une méthode writeBytes()
qui attend deux paramètres :
Buffer
est un tableau d'octets contenant au moins NbBytes
bytesNbOctets
est le nombre d'octets à transmettrewriteString()
renvoie un entier :
1
en cas de succès-1
si une erreur s'est produite lors de l'envoi de la chaîne de caractèresint serialib::readBytes ( void *buffer,
unsigned int maxNbBytes,
unsigned int timeOut_ms,
unsigned int sleepDuration_us);
La méthode readBytes()
lit un tableau de maxNbBytes
octets sur le périphérique série.
Cette méthode attend deux paramètres obligatoires et deux paramètres optionnels :
buffer
est le tableau que la fonction remplit avec les octets lus. Notez que l'allocation de mémoire doit être suffisamment grande pour stocker les octets.maxNbBytes
est le nombre maximum d'octets lus. Lorsque le nombre d'octets lus est égal à maxNbBytes
, l'éxécution de la fonction se termine.timeOut_ms
[optionnel] est le délai d'attente en millisecondes. Lorsque le délai est écoulé, la fonction remplit le tableau et quitte. Si le délai d'attente est fixé à zéro ou n'est pas fixé, le timeout est désactivé.sleepDuration_us
[optionnel] est le délai de relaxation du CPU en microsecondes (Linux uniquement). Après chaque fois que la fonction essaie de lire des données sur le périphérique série, le CPU est relaxé pour effectuer d'autres tâches (thread par exemple).La fonction renvoie le nombre d'octets lus en cas de succès.
En cas de problème, la fonction renvoie l'une des valeurs suivantes :
0
le délai d'attente est atteint-1
erreur lors du réglage du Timeout-2
erreur lors de la lecture des octetsL'exemple suivant envoie un tableau de 8 octets. Ensuite, il essaye de lire 8 octets sur la liaison série. Cet exemple a été testé avec une Arduino qui retourne chaque octet reçu multiplié par deux. Téléchargez l'exemple complet sur Github.
// Serial object
serialib serial;
// Connection to serial port
char errorOpening = serial.openDevice(SERIAL_PORT, 115200);
// If connection fails, return the error code otherwise, display a success message
if (errorOpening!=1) return errorOpening;
printf ("Successful connection to %s\n",SERIAL_PORT);
// Create an array of bytes
unsigned char prime[8] = { 1, 3, 5, 7, 11, 13, 17, 19 };
// Write the array on the serial device
serial.writeBytes(prime, 8);
printf ("Data sent\n");
// Read the bytes
unsigned char received[8];
serial.readBytes(received, 8, 2000, 1000);
// Display each byte received
for (int i=0; i<8 ; i++)
printf("Receive [%d] = %d\n", i, received[i]);
// Close the serial device
serial.closeDevice();
return 0 ;
Voici le code Arduino utilisé pour vérifier l'exemple :
// Setup, initialize
void setup() {
Serial.begin(115200);
}
// Loop forever
void loop() {
// If serial data is pending, read, write twice the received byte
if (Serial.available())
Serial.write( 2*Serial.read() );
}
Si tout se passe bien, le code C devrait afficher quelque chose comme :
Successful connection to /dev/ttyACM0
Data sentReceive [0] = 2
Receive [1] = 6
Receive [2] = 10
Receive [3] = 14
Receive [4] = 22
Receive [5] = 26
Receive [6] = 34
Receive [7] = 38