Moniteur matériel PC : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Salut à tous. J'ai commencé ce projet pour deux raisons: j'ai récemment construit une boucle de refroidissement par eau dans mon ordinateur et j'avais besoin de quelque chose pour remplir visuellement de l'espace dans le boîtier ET je voulais pouvoir vérifier les températures et d'autres statistiques avec un coup d'œil rapide sans manigances OSD remplissant le coin de l'écran. Bien sûr, il existe des solutions toutes faites pour cela, mais la plupart d'entre elles ne correspondraient tout simplement pas à mon feng shui. Ainsi, au lieu de mettre un écran HDMI 7 dans mon boîtier avec un câble dépassant du boîtier et la barre des tâches Windows toujours allumée, j'ai décidé de construire mon propre jouet.

Comme je ne suis ni ingénieur ni programmeur, mais juste un gars avec un fer à souder et des connaissances autodidactes, ce ne sera pas seulement une instruction pas à pas, je vais aussi essayer de me concentrer sur le problème les aspects de résolution et de recherche qui m'ont conduit à cette construction.

AVIS DE NON-RESPONSABILITÉ: TOUT MON TRAVAIL EST PARTAGÉ EN TANT QU'ATTRIBUTION COMMUNE CRÉATIVE-SHAREALIKE 4.0. JE ME SUIS INSPIRÉ DE NOMBREUX EXEMPLES SUR INTERNET, SI VOUS RECONNAISSEZ UNE PARTIE DE CE TRAVAIL COMME LA VTRE, VEUILLEZ ME CONTACTER POUR UNE ATTRIBUTION. AUCUNE CONTREFAÇON N'EST VUE, JE SERAI HEUREUX DE CORRIGER TOUTE ERREUR. MERCI

DEUXIÈME AVIS DE NON-RESPONSABILITÉ: MON TRAVAIL EST PARTAGÉ TEL QUEL. JE NE SUIS PAS RESPONSABLE DES DOMMAGES DÉRIVÉS DE L'UTILISATION DE MON CODE OU DE MES INSTRUCTIONS

Fournitures

• Arduino Nano (ou UNO si vous voulez)
• Écran TFT. Dans mon cas, il s'agit d'un écran 3,5" compatible ILI9486 / ILI9488L.
• Senso de température. Dans le cas mu, un capteur de température analogique TMP36.
• Câbles, fils, connecteurs dupont (plus à ce sujet plus tard)
• (facultatif) Planche à pain pour les tests
• (facultatif mais recommandé) un petit perfboard

Étape 1: Étude de faisabilité (en quelque sorte)

Comme je l'ai dit, je ne voulais pas et l'affichage HDMI est resté coincé dans le boîtier de mon PC, alors, masqué par ma propre ingéniosité, j'ai commencé à rechercher des idées similaires sur Internet. Et c'est le conseil numéro un: Google est votre ami (enfin, tout moteur de recherche décent…). Nous vivons dans un monde où plus rien n'est vraiment original, mais au lieu de regarder cette phrase avec un sens négatif, nous pourrions l'utiliser à notre avantage: quoi que vous vouliez créer, quelqu'un quelque part a probablement déjà fait quelque chose de similaire, donc si vous ne savez pas comment mettre en œuvre une idée, il y a de fortes chances que vous y trouviez des informations utiles. Lors d'une recherche sur Internet, il est souvent utile de garder à l'esprit deux règles:

1. ne vous embêtez pas après la page 3 ou 4 de n'importe quelle recherche, c'est presque toujours une perte de temps. Au lieu
2. changez les termes de recherche, reformulez simplement la question d'un autre point de vue (c'est-à-dire: "capteur de température arduino" -> "lire la température avec arduino").

En fait, c'est plein de bons projets, et j'avoue avoir passé les premiers jours à étudier la plupart de ces projets. Mais aucun d'entre eux n'était prêt à partir pour moi, car je voulais quelque chose qui corresponde à mes besoins.

Comme je devais faire quelque chose sur mesure, j'ai décidé de me concentrer sur le bon matériel à utiliser et de laisser le côté logiciel pour plus tard, car le logiciel peut toujours être créé et adapté aux besoins, par contre côté matériel je suis lié à la disponibilité et fonctionnalités.

Je voulais quelque chose basé sur Arduino, car je l'avais déjà, il est bien documenté et sa communauté est florissante. Pas de problème ici, comme je l'ai dit avant plein d'informations.

Je voulais un écran assez grand pour être vu clairement à quelques mètres de distance et qui correspondrait à l'apparence de ma construction, cela excluait tout affichage de caractères Nokia et LCD. Les OLED sont également hors de question, car ils sont petits. J'ai donc opté pour un écran couleur TFT. Pas besoin d'écran tactile, car il sera à l'intérieur du PC. J'en ai trouvé un 3,5 , déjà conçu pour Arduino, ~15€ sur Amazon. Assez bien.

Maintenant, une fois le matériel identifié, je me suis concentré sur le logiciel.

Presque tous les projets, côté Arduino, sont assez similaires. J'ai juste besoin d'adapter le code de l'affichage et du protocole de communication pour récupérer les données de l'application serveur. Côté informatique, la plupart des projets étaient basés sur C, C++, C#, python et la plupart des projets n'offraient qu'une interface CLI ou un serveur de type service Windows. Je voulais plutôt une interface graphique. Je n'ai jamais utilisé de langage de type C sous Windows, sans parler de la construction de l'interface graphique. Mais j'ai appris quelques notions de Visual Basic il y a 15 ans, alors je l'ai essayé et j'ai téléchargé la version gratuite de Visual Studio de Microsoft.

Après avoir étudié de nombreux projets similaires, je me suis décidé à utiliser OpenHardwareMonitor pour obtenir toutes les informations matérielles et RivaTuner pour FPS, car ils sont gratuits et suffisamment documentés.

Étape 2: Test du matériel

Avant d'allumer le fer à souder et de fixer définitivement dans le temps et dans l'espace tout composant électronique, il est recommandé de construire un prototype de test (astuce numéro deux). Heureusement, nous ne sommes plus en 1995. De nos jours, il est assez facile d'organiser des prototypes assez complexes, même sur de petites planches à pain. Dans mon cas, l'écran TFT avait une chute de brochage pour Arduino Uno, je l'ai donc laissé tomber sur mon Arduino uno et j'ai commencé à jouer avec les bibliothèques d'exemples et à lire les manuels de référence pour comprendre ses principes de fonctionnement et ses limites.

À ce stade, j'ai compris comment dessiner des lignes et des bitmaps et écrire du texte, j'ai donc commencé à jouer avec le codage logiciel, laissant tous les éléments secondaires pour plus tard, mais j'inclurai ici le capteur de température.

À un moment donné, j'avais un espace vide sur l'écran mais aucune des données des capteurs du PC n'était vraiment utile, j'ai donc décidé de mettre un capteur de température à l'intérieur du boîtier pour la température ambiante. L'écran consomme presque toutes les broches Arduino, heureusement la broche analogique A5 n'est pas utilisée, j'ai donc attaché un TMP36. J'ai même testé un DHT22 mais c'est bien excessif pour cette application.

Il y a plein d'exemples pour le TMP36, je viens d'en copier un dans une fonction. Le TMP35 a 3 broches, Vin va à 5V, GND va à la masse et Out va à la broche A5. J'ai placé un condensateur céramique de 0,1 uF entre Vin et GND. Ils disent que c'est nécessaire. C'est probablement inutile dans ce cas, mais… J'ai même réglé la tension de référence analogique Arduino sur la broche 3.3v pour une meilleure lecture de la température. Toujours inutile dans ce cas, mais…

Étape 3: Code Arduino

Veuillez télécharger et ouvrir le code Arduino inclus pour suivre les explications de cette étape. J'ai essayé de laisser suffisamment de commentaires dans le code pour être clair sans l'inonder.

Vous aurez définitivement besoin des librairies MCUFRIEND_kbv et Adafruit GFX. Les deux facilement installables à partir de l'IDE Arduino.

Le programme peut être subdivisé en sections comme ceci:

1. définir et déclarer toutes les variables globales et autres éléments nécessaires
2. initialiser l'affichage, définir la référence externe et dessiner l'UI (tout cela est contenu dans la fonction setup(), car elle ne doit s'exécuter qu'une seule fois)
3. lire les données de la connexion série et les allouer dans le tableau (fonction loop())
4. lire les données du capteur de température externe (fonction readExtTemp())
5. imprimer les données à l'écran (fonction printData())
6. retour à la boucle

SECTION 1: Déclarations et définitions

Dans la section initiale du code, j'ai utilisé beaucoup de pointeurs et de tableaux, j'ai donc pu réduire beaucoup de lignes de code répétitives pour écrire des cycles FOR. Oui, je suis paresseux. Comme vous pouvez le voir, j'ai déclaré un tableau de pointeurs et je l'ai rempli avec toutes les images du fichier pics.h. Cela a permis de faire l'astuce du cycle FOR pour dessiner toutes les icônes.

SECTION 2: setup(), principalement le dessin de l'interface utilisateur

J'ai opté pour la police par défaut car elle n'a pas de fond transparent, elle permet donc d'écrire une nouvelle ligne de texte sur une ancienne sans avoir besoin de la supprimer. L'utilisation d'une autre police aurait signifié dessiner un carré noir sur l'ancien texte avant d'écrire une nouvelle ligne, entraînant un effet de scintillement désagréable.

Après quelques tests, j'ai trouvé un bon compromis entre lisibilité et informations affichées. J'ai divisé l'affichage en deux colonnes et 5 lignes. La colonne de gauche contient les données du processeur et de la carte mère, y compris de haut en bas le nom du processeur, la température, la charge, l'utilisation de la RAM et la température de la carte mère. Le bon dédié au GPU et comprend le nom du GPU, la température, la charge, le compteur d'images par seconde et le capteur de température externe.

Comme vous pouvez le voir dans le code, j'ai décidé d'éviter d'utiliser des images sur la carte SD, car elle est vraiment lente à charger. J'ai décidé d'inclure toutes les icônes dans la mémoire PROGMEM et de tracer les lignes avec la commande dédiée drawLine(). ceci est également utile pour les petites corrections de l'interface utilisateur.

Dans la faible tentative de donner à l'interface utilisateur un semblant de profondeur, j'ai dessiné deux de tout (lignes, rectangles, images) avec des couleurs différentes et avec un petit décalage. Ce n'est malheureusement pas le résultat que j'espérais, mais ça fera l'affaire.

Les dernières lignes de cette fonction sont destinées à imprimer les espaces réservés sur le TFT, jusqu'à ce que l'Arduino reçoive les données.

SECTION 3: boucle principale(), récupération et formatage des données

Ici, la magie opère: les données sont reçues par série, affectées à la bonne variable puis imprimées. Pour réaliser tout cela en un minimum de lignes, j'ai utilisé une commande switch case et un for cycle.

Le protocole de communication avec lequel j'ai été livré est divisé en deux parties: une première exécution et une première poignée de main et la partie des données réelles.

La poignée de main est nécessaire pour mettre en œuvre la fonction de connexion automatique lorsque le programme PC démarre. Ça va comme ça:

• Le PC envoie la chaîne de prise de contact (dans ce cas, il s'agit simplement de "*****;")
• Arduino renvoie une réponse

Peasy facile.

La partie données ressemble à ceci: "i:xxx, yyy, zzz, aaa,;" la signification est:

"i" est l'index, je l'ai appelé componentSelector dans le code. Les valeurs "i" sont:

• i=0 - NOMS. Les valeurs suivantes sont les noms affichés dans la première ligne de l'écran. Cela ne sera envoyé et imprimé sur l'écran qu'une seule fois, à ce jour, il est assez difficile d'échanger à chaud le CPU et le GPU…
• i=1 - 1st COLUMN DATA - les valeurs suivantes sont affichées dans la moitié gauche de l'écran de haut en bas. Dans mon cas: température du processeur, charge du processeur, utilisation de la RAM, température de la carte mère.
• i=2 - 2nd COLUMN DATA - comme ci-dessus, mais pour la moitié droite de l'écran
• i=3 - COMMANDE D'IMPRESSION. Dans ce cas, la chaîne de série brute sera simplement "3:;" car d'autres données ne sont pas nécessaires.

"xxx, yyy, zzz, aaa" sont les valeurs réelles. ceux-ci sont lus comme des chaînes par l'arduino et tout le formatage est effectué par le programme PC. Pour i=0, ces valeurs sont de 14 caractères chacune pour les noms de matériel. Pour i=1 ou 2, il ne s'agira que de trois caractères chacun, assez pour afficher les températures et les images par seconde. Bien sûr les ":", ", " et ";" les caractères sont interdits dans ces champs.

Le ":" est le séparateur entre componentSelector et les valeurs, le ", " est le séparateur de valeurs et le ";" est la fin de la ligne

Lors de la réception des données, l'Arduino les enregistrera sous forme de chaîne jusqu'à ce que le ";" symbole est reçu, puis il recherchera le symbole ":" et l'utilisera pour obtenir la valeur componentSelecor. Ceci sera utilisé pour la fonction de boîtier de commutation afin de sélectionner la procédure correcte à suivre. Il est également utilisé pour sélectionner l'index correct dans le tableau allData.

Après cela, l'Arduino recherchera le symbole ", " et mettra les valeurs dans le tableau allData.

Si componentSelector est 0, l'indicateur printName sera défini sur true. Si componentSelector est 3, les fonctions readExtTemp() et printData() sont appelées.

Section 4: fonction readExtTemp()

Pas grand chose à dire ici, il lit 32 fois à partir de la broche A5 et sort la valeur de température sous forme de chaîne. Je suis avec les rebelles, donc j'utilise Celsius. Tout ce qui est supérieur à 100°C est incorrect, il sera donc affiché sous la forme "---" sur l'écran. Pour tout ce qui est inférieur à 100°C sera formaté pour avoir suffisamment d'espaces pour couvrir l'espace de 3 caractères sur l'affichage. Il est possible de retirer et de réinsérer le capteur et aucune valeur étrange ne sera affichée.

Section 5: fonction printData()

Comme toujours, j'ai utilisé des cycles pour imprimer séquentiellement des éléments à l'écran. Si le drapeau printNames est vrai, il imprimera les noms, définira le drapeau sur faux et continuera.

Section 6: retour à la boucle

Assez explicite, je dirais…

fichier pics.h

Ici, j'ai stocké toutes les icônes de l'interface utilisateur. Il est possible d'utiliser le lecteur de carte SD inclus dans l'affichage, mais il me restait suffisamment de mémoire dans l'Arduino pour mes icônes en noir et blanc.

Je les ai conçus avec Junior Icon Editor car c'est gratuit et assez bon pour peindre de petites icônes en pixels. J'ai dû convertir les fichiers d'icônes (enregistrés au format PNG) avec l'outil en ligne SKAARHOJ.

Étape 4: Code Visual Basic

Voici le code VB

AVIS: c'est la première fois que je partage un projet Visual Studio. Je viens de copier les dossiers du projet et de les compresser. Si cela ne fonctionne pas, s'il vous plaît laissez-moi savoir une meilleure façon de partager ce genre de projets. Merci

Comme je l'ai dit plus tôt, je suis incapable de créer une interface graphique en C# ou dans d'autres langages, mais j'ai eu quelques expériences en Visual Basic il y a longtemps. J'ai téléchargé l'édition Visual Studio Community (c'est gratuit bien sûr) avec l'environnement Visual Basic. Bon, j'ai dû trouver plein de trucs, car la dernière fois que j'ai utilisé VB c'était la version 2005 ou autre… Mais Internet regorge de bons conseils, comme d'habitude.

Après avoir compris quelques éléments d'interface, la nouvelle version est en fait plus facile et plus flexible que l'ancienne.

Pour ce programme, je voulais quelque chose avec un formulaire Windows mais entièrement gérable à partir d'une icône de la barre d'état système. En fait, j'ai utilisé le formulaire presque uniquement à des fins de débogage, car j'aime mettre des zones de texte et des listes pour lire les valeurs de sortie des fonctions et certains boutons de commande pour les tester.

Le programme "final" n'est qu'une icône de la barre d'état avec un menu contextuel qui affiche les différents contrôles et un formulaire principal avec deux zones de liste qui affichent les données envoyées à l'Arduino.

J'ai implémenté une fonction autoconnect et une fonction "start at boot". Plus à ce sujet plus tard.

Le programme principal n'est qu'une adaptation de divers exemples et extraits de code utilisant la bibliothèque OpenHardwareMonitor et la bibliothèque RivaTuner Shared Memory.

Le programme se déroule ainsi:

• obtenir les données des bibliothèques OpenHardwareMonitor et RTSSSm
• préparer et formater toutes les données pour le protocole de communication
• envoyer les données à l'Arduino
• rincer et répéter

bien sûr, les noms de matériel sont lus au démarrage et envoyés une seule fois.

Le compteur FPS ne s'active que lorsqu'une application compatible est utilisée (par exemple un jeu, un programme de modélisation 3D, etc.), sinon l'espace réservé "---" sera envoyé à l'écran.

Je ne vais pas expliquer en profondeur comment obtenir les valeurs des bibliothèques, car elles sont bien documentées sur Internet et quelque peu compréhensibles à partir du code. Je veux juste parler des problèmes d'affichage de la température de la carte mère via la bibliothèque OpenHardwareMonitor (à partir de maintenant OHMonitor, car la durée de vie est trop courte). J'ai un Asus Maximus VIII Gene MoBo, qui est équipé d'un capteur de température fu ** tonne sur la carte mère, mais OHMonitor les nomme Capteur de température #1, #2 … #n ET nulle part l'emplacement de la température n'est spécifié. J'ai donc dû installer le terrible logiciel de la suite Asus AI, où les capteurs ont au moins des NOMS et comparent les différentes températures entre les deux programmes. Il semble que le capteur de température générique de ma carte mère soit n ° 2 pour OHMonitor, donc comme vous pouvez le voir dans le sous-titre Timer1_tick sous les éléments MoBo, j'ai dû rechercher un nom de capteur contenant la chaîne " n ° 2 " pour obtenir la lecture correcte.

TL; DR: vous devrez vous occuper des bons capteurs de température de la carte mère. Le reste est probablement prêt à partir.

Cependant, il ne s'agit que de la version 1, je prévois d'installer ce gadget sur mon autre PC, je vais donc probablement mettre en œuvre un moyen de sélectionner les capteurs et peut-être même repenser l'interface sur l'Arduino en déplacement.

La fonction de connexion automatique

Cette fonction est en fait simple: si le PC n'est pas connecté à un Arduino, toutes les x millisecondes (en fonction du Timer1) cette fonction est appelée. Il essaie de se connecter à chaque port COM du PC, en cas de succès, il envoie la chaîne de poignée de main "*****;". Si la réponse est "R", alors le bon appareil est connecté et la procédure normale est suivie. Sinon, il essaie le prochain port COM.

Comme vous pouvez le voir, il y a beaucoup d'exceptions dans cette fonction. C'est parce que je le voulais entièrement plug and play, sans sortie d'erreur. En gérant les exceptions, j'ai pu lui faire ignorer l'absence totale du périphérique externe et je peux même brancher et débrancher à chaud le périphérique quand je le souhaite, sans générer d'erreur de rupture pour le programme.

La fonction Démarrer au démarrage

Je voulais que le programme démarre au démarrage. Assez facile, dites-vous. Mettez un lien dans le dossier approprié, dites-vous. Mais non. En raison des bibliothèques OHMonitor et RTSS, nous avons besoin d'un niveau d'exécution administrateur pour collecter les informations. Cela signifie l'écran UAC tout à fait ennuyeux à chaque fois que cette application est lancée. Certainement pas. J'ai donc adapté le script réalisé par Matthew Wai (lien ici) pour obtenir un démarrage silencieux au démarrage. J'ai juste copié le script dans le fichier Resources1, divisé en plusieurs parties, puis implémenté un sous-programme qui crée (ou supprime) un fichier de tâche Windows, personnalisé avec l'emplacement actuel de l'exécutable du programme et autres.

L'icône de la barre d'état système

Grâce aux objets NotifyIcon et ContextMenu, j'ai pu implémenter un moyen simple et efficace de contrôler l'application. Faites un clic droit sur l'icône de la barre d'état et le menu apparaît. Il y a ces options:

• Démarrer au démarrage: vous pouvez cocher et décocher pour activer ou désactiver la fonction de démarrage au démarrage
• Connexion automatique: comme ci-dessus, mais gère la fonction de connexion automatique
• Connecter/Déconnecter: il gère la connexion. Ne fonctionne pas avec la connexion automatique activée
• Temps de rafraîchissement: donne un sous-menu déroulant, vous pouvez choisir le temps de rafraîchissement de 1 à dix secondes
• Maximiser: ouvre la fenêtre principale. Identique au double-clic sur l'icône
• Sortie: explicite

Compilation du logiciel

Pour compiler le logiciel, vous aurez probablement besoin de télécharger et d'ajouter une référence aux bibliothèques non incluses dans le code.

Vous pouvez trouver la bibliothèque OpenHardwareMonitor ici. Vous devez télécharger le logiciel, ouvrir le fichier zip et copier le fichier OpenHardwareMonitorLib. DLL dans le dossier du projet.

Voici le lien pour la bibliothèque RTSSharedMemoryNET, vous devez télécharger et compiler pour votre architecture, puis copier le RTSS[TL;DR]moryNET. DLL dans le dossier de votre projet.

Maintenant, vous devez ajouter une référence dans votre code, instructions ici

Assurez-vous simplement de compiler les projets de serveur RTSS[TL;DR]moryNET et PCHwMon pour la même architecture.

J'ai inclus un programme d'installation prêt à l'emploi, vous pouvez donc installer le tout sans jouer avec Visual Basic. Il est compilé pour x86, fonctionnera sur les architectures x86 et x64. Il nécessite le framework. NET 4.7.2 pour s'exécuter.

Dans tous les cas, vous devrez installer RivaTuner. Vous pouvez le trouver ici en tant qu'application autonome ou vous pouvez installer Msi Afterburner, qui devrait inclure le RTServer.

Étape 5: Implémentation matérielle finale