Générer des nombres pseudo-aléatoires avec une carte Arduino / Genuino

4 8 15 16 23 42

par skywodd | March 15, 2017 | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino Random Aléatoire

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.

Dans ce tutoriel, nous allons apprendre ensemble à générer des nombres (pseudo) aléatoires avec une carte Arduino / Genuino. En bonus, nous verrons en image pourquoi ces nombres sont dits "pseudo" aléatoires.

Sommaire

• Avant-propos
• Générer des nombres pseudo aléatoires avec une carte Arduino
• Bonus : Le "pseudo" aléatoire en image
• Conclusion

Bonjour à toutes et à tous !

Désolé de casser un mythe, mais en informatique, l'aléatoire n'existe pas. L'informatique est une science froide et déterministe.

Qu'importe le nombre de fois qu'on exécute, un programme avec un jeu de données précises, il ne va pas spontanément devenir conscient de sa propre existence et se récrire pour conquérir le monde (quoi que, cela pourrait bien finir par arriver). Un programme va systématiquement suivre une série d'instructions et retourner un résultat identique à chaque fois.

Cependant, on a parfois besoin d'un peu d'aléatoire dans nos programmes. On peut vouloir par exemple créer des identifiants d'objets (UUID) ou des noms de fichiers temporaires. Pour cela on a besoin de nombres aléatoires.

Avant-propos

Les nombres générés par la fonction random() présentée ci-dessous sont dits pseudo aléatoires. Cela signifie qu'ils sont aléatoires en apparence, mais qu'en réalité, pas vraiment.

On verra en bonus la subtilité qui existe entre aléatoire et pseudo aléatoire. Pour le moment, retenez bien ceci : la fonction random() ne doit pas être utilisée pour des opérations de sécurité / cryptographie.

Heureusement (ou malheureusement ?), en programmation sur microcontrôleurs, on utilise très peu souvent de la cryptographie. Vous pouvez donc savourer cet article sans crainte

Générer des nombres pseudo aléatoires avec une carte Arduino

La génération de nombres pseudo-aléatoires avec une carte Arduino / Genuino se fait en deux étapes.

1

randomSeed(graine);

Tout d'abord, quelque part dans votre fonction setup(), il vous faudra appeler la fonction randomSeed().

Cette fonction prend en argument une "graine" (un nombre entier) qui permet d'initialiser le générateur de nombres pseudo-aléatoires. En fonction de la valeur de la graine, vous obtiendrez une suite de nombres complètement différente.

1
2
3

void setup() {
  randomSeed(analogRead(0));
}

Une façon "classique" d'initialiser le générateur de nombres pseudo-aléatoires est d'utiliser la valeur retournée par une broche analogique "flottante" (reliée à rien). Cela permet d'avoir une graine différente à chaque exécution du code, et donc, une suite de nombre pseudo aléatoires différentes à chaque fois.

N.B. Si vous n'initialisez pas le générateur ou que vous utilisez une graine de valeur fixe, vous obtiendrez toujours la même suite de nombres aléatoires.

1
2

long random(max);
long random(min, max);

Une fois le générateur pseudo-aléatoire initialisé, vous pouvez utiliser la fonction random() pour obtenir des nombres pseudo-aléatoires.

La fonction random() prend en arguments une valeur maximum et minimum (0 par défaut) et retourne une valeur aléatoire entre la valeur minimum et maximum – 1.

Exemple : random(256) peut retourner des valeurs entre 0 et 255. random(-12, 13) peut retourner des valeurs entre -12 et +12.

PS N'oubliez d'ajouter +1 à votre valeur maximum attendue, c'est une erreur classique de débutant

Exemple d'utilisation :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/** Fonction setup() */
void setup(){

  /* Initialise le port série pour le debug */
  Serial.begin(9600);

  /* Initialise le générateur de nombre aléatoire avec une graine aléatoire */
  randomSeed(analogRead(0));
}

/** Fonction loop() */
void loop(){

  /* Génére un nombre aléatoire entre 0 et 255 et l'affiche sur le port série */
  long nombre = random(256);
  Serial.println(nombre);

  /* Délai pour l'affichage */
  delay(500);
}

Bonus : Le "pseudo" aléatoire en image

L'image ci-dessus est une représentation graphique de 256 000 valeurs consécutives générées par la fonction random().

Vous ne remarquez rien de spécial ? Un indice : les barres verticales noires.

En réalité, les valeurs retournées par la fonction random() ne sont pas du tout aléatoires. Comme je le disais en introduction, l'informatique ne laisse pas de place pour l'aléatoire.

Derrière la fonction random() se cache une fonction mathématique qui génère une très longue suite de nombres, d'apparences aléatoires. Si on génère suffisamment de nombres, on peut remarquer que la suite de nombres se répète au bout d'un moment.

La fonction randomSeed() permet de faire démarrer la suite de nombres à un endroit arbitraire dans la liste. Cela donne l'impression d'avoir des nombres complètement aléatoires. Cependant, si vous connaissez la valeur actuelle de la graine, vous pouvez déterminer la valeur de n'importe quels nombres pseudo-aléatoires présents, passés et futurs.

C'est pour cela qu'il s'agit de nombres pseudo-aléatoires et non de nombres aléatoires. Pour obtenir de vrais nombres aléatoires, il faudrait utiliser un générateur matériel de nombres aléatoires. Certains microcontrôleurs disposent de ce genre de générateurs, mais ce n'est pas le cas des cartes Arduino.

Si vous utilisez des nombres pseudo-aléatoires pour faire de la cryptographie, vous allez avoir un souci. Par contre, pour générer un nom de fichier aléatoire ou réaliser une bougie électronique DIY, là, pas de soucis

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le partager sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.

Cliquez ici pour accéder aux commentaires de l'article.