Voici une idée plutôt originale qui pourrait intéresser les fans de formule 1 et notamment ceux du jeu F1 2013 édité par Codemasters. Le principe de base est de se servir des données que le jeu renvoi (qui sont initialement prévus pour l’utilisation d’un volant) afin d’afficher les informations concernant le régime moteur (notamment le moment optimal du passage de rapport) en utilisant plusieurs séries de LED comme c’est le cas sur un volant de F1. Nous avons aussi ajouté un écran LCD permettant d’afficher 2 lignes de 16 caractères afin de renvoyer des informations telles que la position en course, le temps au tour, le rapport de boite engagé ou encore la vitesse (cet affichage peut néanmoins être adapté selon votre choix). Voici une petite vidéo vous présentant ce que cela peut donner :

Ce projet est compatible avec les anciens jeux de la série F1 game de Codemasters à partir du moment où le jeu permet la transmission des données. De plus il est possible d’adapter cette solution aux autres jeux issus de cet éditeur pour peu qu’eux aussi répondent à la condition citée précédemment. Il n’est pas nécessaire d’avoir les 2 systèmes fonctionnels en même temps. Vous pouvez choisir d’utiliser uniquement les LED ou l’affichage sur l’écran LCD. Je suis conscient que cette idée n’est pas d’une utilité extra ordinaire, mais elle est a le mérite d’être fun et pourra peut-être développer la créativité de certaines personnes =D.

Le schéma électronique

Voici le schéma électronique de notre système (cliquez dessus afin de l’agrandir) :

Concernant les LED

Nous allons donc commencer par la présentation du schéma électronique. Le prototype a été réalisé à l’aide d’une plaque de test, mais il est facilement possible de réaliser un véritable système. Le nombre de LED peut lui aussi varier (il est possible d’en mettre 5 comme sur un vrai volant de F1).

La couleur des LED importe peu (c’est vous qui choisissez ce que vous voulez mettre), j’ai pris des bleues, des oranges et des roses, car je les avais sous la main. Certaines LED sont reliés à des résistances et d’autres non. Cela dépendra du type de LED utilisée. En effet dans mon cas, les LED bleues et roses avaient besoin d’une tension comprise entre 3,2 V et 3,8 V pour fonctionner (les ports GPIO délivrent une tension de 3,3 V) alors que les oranges n’acceptent que du 1,8 V au 2,2 V. Vous serez obligé de les brancher en parallèle, car la tension de sortie des ports GPIO n’est pas suffisante pour alimenter 2 LED en série (voir la loi d’additivité des tensions dans un circuit en série).

Pour économiser des résistances, il est possible de n’en utiliser qu’elle seule pour les 3 LED (en la plaçant en série avant le groupe de LED). Néanmoins il faudra adapter la valeur de la résistance en fonction du nombre de LED selon la formule : R = (Ugpio – Uled) / (nombreLed * Iled). De plus ceci n’est pas recommandé dans le cas ou le nombre de LED serait plus important, car les petites résistances électroniques sont conçues pour résister à un nombre limité de Watt (0,25 W dans mon cas) et la rupture d’une LED aurait pour effet de faire griller toutes les autres (car la valeur de la résistance doit être diminuée en fonction du nombre de LED afin de laisser passer une plus grande intensité). Pour mes tests j’ai utilisé une résistance de 68 ohms pour mes 3 LED ce qui avait pour conséquence de ne pas les faire briller à leur maximum, mais qui me préservait en cas de rupture d’une LED (68 ohms est la valeur nécessaire pour protéger une seule LED orange).

Concernant l’écran LCD

Pour l’écran LCD, nous n’allons pas évoquer en détail son branchement dans ce tutoriel. En effet ce sujet fera l’objet d’un futur article au sein de notre site web, car il y a beaucoup à dire à ce sujet. En attendant, vous pourrez trouver aisément sur Google des explications concernant le branchement de l’écran en recherchant comment relier un LCD équipé d’un contrôleur  HD44780 sur le Rpi.

Installation de Java

Nous allons maintenant installer Java sur notre Raspberry Pi afin de pouvoir exécuter notre programme chargé de récupérer les données renvoyées par le jeu et de gérer l’affichage des LED. Je vois déjà certaines personnes avoir des éruptions sous-cutanées rien qu’avec le simple faites de lire le mot Java. Mais pourquoi ai-je choisi ce langage ? Car c’est le langage que je maitrise le plus et je savais déjà comment implémenter un socket. De plus, il existe un excellent framework permettant la gestion des ports GPIO nommés Pi4j : http://pi4j.com/. Ne vous inquiétez pas, le logiciel ne consommera pas toutes les ressources de votre Rpi, en effet Oracle a fourni un gros effort pour optimiser sa future version 8 du JDK Java pour les processeurs ARM.

Un tutoriel dédié à l’installation de java existe déjà sur notre site. Rendez-vous directement à cette adresse afin d’obtenir la procédure à suivre : http://code4pi.fr/2013/12/installation-du-java-jdk-8-early-access-sur-le-raspberry-pi/

Modification du fichier de configuration du jeu

Afin que le jeu soit capable d’envoyer les données à notre Rpi il est nécessaire de modifier le fichier de configuration du jeu. Pour cela rendez-vous dans le dossier C:\Users\MonCompte\Documents\My Games\FormulaOne2013\hardwaresettings\ (bien évidement le chemin est à adapter selon votre cas) afin de modifier le fichier nommé hardware_settings_config.xml.

Trouvez alors la balise XML commençant par motion et modifiez-la comme ceci :

<motion enabled="true" ip="address_ip_rpi" port="20777" delay="1" extradata="2" />

Il est donc nécessaire de définir le paramètre extradata à 2 (le mode 2 permet d’avoir des informations complémentaires par rapport au mode 1) ainsi que l’adresse IP du Rpi.

Logiciel de contrôle des Led et de l’écran

Récupération du logiciel

Les sources du logiciel développé afin de contrôler les LED ainsi que le LCD sont disponibles sur Github à l’adresse suivante :

https://github.com/benoitm76/F1TelemetryOnRpi

Pour créer une archive .jar exécutable sur votre Rpi, il vous faut récupérer les sources et les compiler avec ant : ant build.xml.

Vous pouvez bien sûr modifier le code source afin d’afficher sur l’écran les informations que vous désirez.

Néanmoins pour ceux ne maitrisant pas cette technologie, vous pouvez récupérer un le fichier .jar en suivant ce lien :

 F1 Telemetry on RPI v1.02

Fichier de configuration

Si vous avez compilé le logiciel avec ant ou si vous avez téléchargé directement le logiciel depuis notre site, vous devez maintenant avoir un fichier .jar ainsi qu’un fichier de configuration nommé config.properties. Voici une liste des différents paramètres que vous pouvez modifier :

• led_on : Active ou désactive le système de LED (false par défaut, mettez a true si vous souhaitez l’activer)
• lcd_on  : Active ou désactive l’affichage sur le LCD (false par défaut, mettez a true si vous souhaitez l’activer)
• led_first_leds : le port GPIO pour la première série de LED (7 par défaut)
• led_second_leds : le port GPIO pour la seconde série de LED (9 par défaut)
• led_third_leds  : le port GPIO pour la troisième série de LED (8 par défaut)
• lcd_rs : le port GPIO relié au port RS de l’écran (11 par défaut)
• lcd_scrobe : le port GPIO relié au port scrobe de l’écran (10 par défaut)
• lcd_bit_1 : le port GPIO relié au port bit 1 de l’écran (6 par défaut)
• lcd_bit_2 : le port GPIO relié au port bit 2 de l’écran (5 par défaut)
• lcd_bit_3 : le port GPIO relié au port bit 3 de l’écran (4 par défaut)
• lcd_bit_4 : le port GPIO relié au port bit 4 de l’écran (1 par défaut)
• rpm_for_pin_1 : le régime minimal à partir duquel la première série de LED s’allumera (1785 par défaut)
• rpm_for_pin_2 : le régime minimal à partir duquel la seconde série de LED s’allumera (1825 par défaut)
• rpm_for_pin_3 : le régime minimal à partir duquel la troisième série de LED s’allumera (1865 par défaut)
• rpm_for_blinking : le régime minimal à partir duquel les LED se mettront a clignoté (1880 par défaut)
• lcd_refresh_time : temps de rafraîchissement des informations de l’écran LCD en milliseconde (50 par défaut)

Concernant les valeurs de régime moteur, il faut les multiplier par 10 afin d’obtenir la vraie valeur. Néanmoins j’ai décidé de conserver la même unité que celle renvoyée par le jeu.

Attention : La nomenclature des ports GPIO n’est pas la même que celle qu’on utilise habituellement lorsque l’on développe en python. Voici un schéma permettant de retrouver le numéro correct des différents ports GPIO (la partie WiringPi sur le diagramme).

Lancement de l’application

Une fois les branchements effectués et les fichiers transférés sur votre Rpi (le fichier de configuration et le .jar), il ne vous reste plus qu’à lancer l’application (le jeu n’a pas besoin d’être lancé pour démarrer le logiciel sur le Rpi). Pour cela, utilisez la commande :

sudo java -jar F1TelemetryOnRpi_v1.02.jar

Si tout est correctement branché et configuré, les LED devraient clignoter durant 2 secondes et l’écran devrait afficher certaines informations, dont le numéro de version.

Voilà, il ne vous reste plus qu’à vous éclater (au sens propre ou au sens figuré) avec F1 2013.