Tableau de bord - TunerStudioMS et Raspberry PI
L'objectif n'est pas de remplacer le tableau de bord principal, mais de le compléter par un tableau de bord intelligent capable d'afficher tous les paramètres et/ou de les enregistrer.
Afficher des paramètres et/ou les enregistrer, les modifier, .... c'est le boulot de
TunerStudioMS
Il suffit donc de garder le PC connecté sur le boîtier d'injection.
Mais c'est un peu encombrant
Automatiser le système : démarrage et arrêt automatique. A la clé de contact.
Matériel nécessaire :
Un écran (tactile) de 7 pouces pour l'affichage
(tactile pour les commandes de base)
Un Raspberry PI 3B - Pour exécuter TunerStudio MS.
Les interfaces nécessaires.
Pourquoi un Raspberry PI ? Puissant, compact, économique et fonctionnement sous Linux.
Quelques images du système :
Écran du Raspberry avec Raspbian
Écran du Raspberry en fonction Tableau de Bord
*C'est l'écran qui apparaît au démarrage. Lancement automatique du logiciel TunerStudio en mode plein écran.*
Écran du Raspberry en fonction Surveillance
Nota : J'ai découvert qu'avec un écran tactile on pouvait faire défiler les différents tableaux de bord en balayant l'écran (sans sortir du mode plein écran !!!
Écran du Raspberry en fonction Modification Paramètres
Écran du Raspberry en fonction Modification Table Injection 3D
Enfin une photo du hard (Raspberry PI, Écran, câbles !!!!!)
Le système fonctionne.
L'écran LCD de 7 pouces (1024x600) et "touchscreen"
Le Raspberry PI3B+ (Raspbian, TunerStudioMS).
Reste à mettre dans une boite. La plus petite possible, l'écran de 7 pouces à été choisi comme le moins encombrant.
Le problème : **les câbles**.
Le câble HDMI est beaucoup trop raide, les câbles USB beaucoup trop encombrants et longs.
Je dois trouver des prises HDMI, USB, .... à câbler avec des nappes hyper souples.
Si vous avez des pistes, je suis preneur.
Deuxième partie du projet :
le système d'alimentation, de mise en marche, de mise à l'arrêt.
(actuellement on utilise la prise allume cigare - alimentée en permanence - et un adaptateur 12V/5V)
Le système doit démarrer à la mise du contact.
Le système doit s'arrêter à la coupure du contact (sauf si on le remet rapidement), le Raspberry PI doit s'arrêter proprement.
Arrêt propre du Raspberry PI : Le Raspberry PI fonctionne comme un ordinateur. Il a les mêmes exigences qu'un ordinateur : il ne supporte pas toujours un arrêt par coupure de l'alimentation électrique.
Certains fichiers nécessaires au démarrage peuvent être endommagés s'ils ont ouverts ou en cours d'écriture au moment de la coupure.
Il est donc nécessaire de lui donner un ordre d'arrêt avant de couper l'alimentation.
Pour le démarrage, c'est plus simple, il démarre automatiquement à la mise sous tension.
J'ai choisi d'utiliser un Arduino nano pour piloter 2 relais et diverses tempos.
(c'est très économique, je sais le programmer, çà consomme très peu - fonctionnement permanent, c'est robuste - arrêt par coupure d'alimentation, démarrage très rapide, ......
Un relais envoi un signal d'arrêt au Raspberry PI (pendant x secondes)
Un relais gère l'alimentation générale.
Prototype
Le prototype est fonctionnel.
2 leds permettent de simuler les entrées du Raspberry PI (alimentation 5V après relais, contact fermé pour signal d'arrêt).
Le signal d'arrêt sera envoyé sur le port GPIO du Raspberry PI - Mise à la masse pendant 2 secondes du port GPIO 23. (Entrée 23 choisie car situe à proximité d'un port Masse.
Un script (écrit en python) tourne en tâche de fond. A la réception du signal sur la broche GPIO 23 (pendant une durée de 2 secondes), il lance les instructions nécessaires :
- à la fermeture de TunerStudio.
- à l'arrêt du Raspberry PI.
Le script python :
piShutdown.py
Code : Tout sélectionner# !/bin/python
# -*- coding: utf-8 -*-
# Simple script pour arrêter le Raspberry PI à la réception d'un signal d'arrêt sur une broche GPIO
import RPi.GPIO as GPIO #Librairie pour l'utilisation du port GPIO
import time # Librairie pour les fonctions temps
import os # Librairie pour les commandes d'arrêt
# Utilise la numérotation Broadcom SOC pour les numéros de broches
# Configure la broche d'entrée en pullup
GPIO.setmode(GPIO.BCM)
GPIO_shutdown=23 # Numero de connecteur pour le bouton d'arrêt
GPIO.setup(GPIO_shutdown, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#La fonction à exécuter lors d'un signal d'arrêt
while True: #Boucle infinie.
if GPIO.input(GPIO_shutdown) == GPIO.LOW: #Teste si la broche d'entrée est à la masse
time.sleep(1) # Attend pour confirmer
if GPIO.input(GPIO_shutdown) == GPIO.LOW: #Teste pour vérifier que la broche d'entrée est toujours à la masse
os.system("killall -w java") #Fermeture de TunerStudio
os.system("shutdown now -h") #Arrêt du PI
time.sleep(1) # Temps d'attente pour ne pas surcharger le processeur.
Pour que dispositif fonctionne, il faut exécuter le script au démarrage. Modifier le fichier rc.local (rc.local est une liste de tâches que le Pi suit au démarrage). Ouvrir en tant que super utilisateur (sudo). Utiliser leafpad pour éditer rc.local (c’est plus simple que nano).
Dans rc.local, ajouter une commande pour exécuter le script d’arrêt, à la ligne précédant l’exit 0.
Important le «&» à la fin indique au Pi d’exécuter ce programme en arrière-plan.
Le relais "intelligent" (à base d'Arduino nano) gérant le démarrage et l'arrêt du TdB par la clé de contact.
Le signal d'entrée :
- Présence ou non du 12 Volts après contact.
Les signaux de sortie :
- Signal d'arrêt du Raspberry PI (relais)
- Signal alimentation du TdB - Raspberry PI & Ecran - (relais).
La fonction :
- Démarrage du tableau de bord à la mise du contact (+12V ApC)
- Arrêt du tableau de bord à la coupure du contact (+12V ApC) -
avec arrêt "propre" du Raspberry PI.
- Maintien en service du tableau de bord à la coupure du contact de courte durée (+12V ApC)
Le schéma de principe :
Le convertisseur 12v -> 5V
Le relais pour la mise en service de l'alimentation
La platine à base d'Arduino nano et ses composants
Elle dispose de sa propre alimentation 12V en 5V, un micro relais pour le signal d'arrêt vers le Raspberry PI.
Le code pour l'Arduino :
RelaisTempo.ino
Code : Tout sélectionnerint APC = 2;
int RELAIS = 3;
int RASPSTOP = 8;
// Déclaration des variables
int memoireAPC = LOW; // Mémoire présence 12 volts après contact
int etatAPC = LOW; //Etat actuel du 12 volts après contact
int etatRelais = LOW; //Etat du relais
int etatRasp = LOW; //Etat signal de commande du Raspberry
unsigned long tempsDem = 45000; //Temps d'attente pour le démarrage du Raspberry
unsigned long tempsArret = 30000; //Temps d'attente pour l'arrêt du Raspberry
unsigned long tempsAtt = 60000; //Temps d'attente avant la mise à l'arrêt du Raspberry après coupure ApC
void setup() {
// On initialise les entrées/sorties
// Serial.begin(9600);
pinMode(APC, INPUT);
pinMode(RELAIS, OUTPUT);
pinMode(RASPSTOP, OUTPUT);
digitalWrite(RELAIS, etatRelais); // On écrit l'état du relais
digitalWrite(RASPSTOP, etatRasp); // On écrit l'état du raspberry
}
void readAPC() {
// Récupération de l'état actuel du Contact (+ 12 Volts Après contact) - toutes les secondes
while (etatAPC == memoireAPC) {
delay(1000);
etatAPC = digitalRead(APC);
/* Serial.print("etatAPC = ");
Serial.print(etatAPC);
Serial.print("; mémoireAPC = ");
Serial.print(memoireAPC);
Serial.print("; etatRelais = ");
Serial.print(etatRelais);
Serial.println(); */
if (etatAPC == LOW && memoireAPC == HIGH) {
// Serial.println("Attente .....");
// On attend pour confirmer la coupure contact.
delay(tempsAtt);
etatAPC = digitalRead(APC);
}
}
}
void loop() {
readAPC();
// Si l'état est différent de la mémoire et qu'il est à HIGH (Front montant)
if (etatAPC != memoireAPC && etatAPC == HIGH) {
// Si relais est LOW - Démarrage du RPI
if (etatRelais == LOW) {
// On demande à le passer à HIGH
etatRelais = HIGH;
digitalWrite(RELAIS, etatRelais);
// On mémorise l'état du Contact (+12V Après contact)
memoireAPC = etatAPC;
// Et on attend ..... le temps que le raspberry démarre
// Serial.println("Démarrage ..............");
delay(tempsDem);
}
}
// Si l'état est différent de la mémoire et qu'il est à LOW (Front descendant)
if (etatAPC != memoireAPC && etatAPC == LOW) {
// Si relais est HIGH
if (etatRelais == HIGH) {
// On demande au Rasberry de s'arrêter
etatRasp = HIGH;
digitalWrite(RASPSTOP, etatRasp);
// On maintient le signal 3s
delay(3000);
etatRasp = LOW;
digitalWrite(RASPSTOP, etatRasp);
// On attend .... secondes l'arrêt du Raspberry
// Serial.println("Arrêt .....");
delay(tempsArret);
// On demande au relais de passer à LOW
etatRelais = LOW;
digitalWrite(RELAIS, etatRelais);
// On mémorise l'état du Contact (+12V Après contact)
memoireAPC = etatAPC;
}
}
}
Un lien vers un dossier Relais Tempo
Reste à traiter :
- La transmission automatique des fichiers "Datalogs" (si créés).
- .........
Nota : Soyons pragmatiques, la manipulation d'un "mini" ordinateur avec un écran tactile et un clavier virtuel est assez limitée. Merci à VNC Viewer qui permet d'utiliser l'écran et le clavier du PC portable via le réseau !!!!
Bonne lecture, à votre disposition si besoin de détails.
La théorie c'est quand on sait tout et que rien ne fonctionne. La pratique c'est quand tout fonctionne et que personne ne sait pourquoi. Moi j'ai réuni théorie et pratique : Rien ne fonctionne... et personne ne sait pourquoi !