Un anno fa è arrivata a casa una TV 4K e finalmente, la settimana scorsa, una scheda video in grado di supportarla a quella risoluzione. La scheda ha un enorme dissipatore di calore, ma nessuna ventola. Nessuna ventola significa non troppo calore (spero), il che significa meno energia richiesta dall'antico alimentatore da 250 W. Il computer esegue Linux e, dopo aver cercato su Internet, ho trovato questi comandi per controllare i sensori di temperatura all'interno del case. Il verde Netflix è il nome del computer Linux.
nvidia-settings and sensors commands to show temperaturenvidia-settings and sensors commands to show temperaturenvidia-settings and sensors commands to show temperaturenvidia-settings and sensors commands to show temperatureComandi nvidia-settings e sensori per mostrare la temperatura
I due comandi mostrano la temperatura di Nvidia (scheda grafica) a 53°C e la temperatura della CPU tra 46°C e 53°C. Anche il comando dei sensori sembra suggerire che gli 80°C siano l’inizio di una zona che inizia a preoccuparsi. Attualmente la scheda video è inattiva mentre scrivo questo post e la temperatura è piuttosto bassa. È molto più difficile visualizzare video 4K a schermo intero e la temperatura aumenterà. Quanto e quanto velocemente?
Per scoprirlo, JMP eseguirà i comandi Linux in loop, registrando i risultati e creando un grafico che si aggiorna man mano che i dati vengono raccolti. La magia sta in RunProgram (una funzione JSL) e plink (un programma esterno, parte del pacchetto putty, che gira su Windows). Prima che funzioni, ci sono alcune cose da fare.
Innanzitutto, il computer host Linux necessita del server SSH in esecuzione e deve essere protetto in modo appropriato. Ho usato siti come Questo E Questo questo per risolvere il problema.
Successivamente avrai bisogno di plink installato sul tuo computer Windows. Ho scelto il programma di installazione MSI Qui e poi leggi Questo per capire come funziona plink.
Infine, configura puttygen/putty/plink per utilizzare la connessione ssh con le chiavi (stesso Questo da sopra) in modo da non mettere la password in bella vista.
Ora esegui un test davvero semplice per vedere se tutto è a posto. Plink è il programma che verrà eseguito dal tuo computer Windows (parte dell'installazione di putty). Netflix è anche il nome della configurazione del mio computer Linux nel programma putty.Sensori è il nome del programma che verrà eseguito dal computer Linux. E testo dice a RunProgram di restituire semplicemente tutto il testo in uscita dai sensori al termine dei sensori.
Output of sensors command showing B0 for degree symbolOutput of sensors command showing B0 for degree symbolOutput of sensors command showing B0 for degree symbolOutput of sensors command showing B0 for degree symbolUscita del comando sensori che mostra B0 per il simbolo del grado
La B0 evidenziata dovrebbe essere un simbolo di grado. RunProgram presuppone che l'output di un eseguibile sia ASCII a 7 bit, non Unicode. Per risolvere questo problema, utilizza l'opzione blob e converti il blob in testo. Questo esempio eseguirà due comandi. La stringa JSL che contiene i comandi utilizza i caratteri \[ e ]\ racchiusi tra virgolette per rendere più semplice l'utilizzo successivo di caratteri speciali, se risultano necessari. Il punto e virgola separa i due comandi Linux. È possibile vedere i valori di interesse evidenziati in giallo, seguiti dai simboli dei gradi (non B0).
RunProgram with the blob option returns binary data which might convert to UnicodeRunProgram with the blob option returns binary data which might convert to UnicodeRunProgram with the blob option returns binary data which might convert to UnicodeRunProgram with the blob option returns binary data which might convert to UnicodeRunProgram con l'opzione blob restituisce dati binari che potrebbero essere convertiti in Unicode
Creare ripetutamente la connessione al computer Linux è OK, ma non è l'ideale. Il sovraccarico può essere evitato creandolo una volta. Lo farò scrivendo un ciclo per l'esecuzione del computer Linux, con un breve ritardo. La ReadFunction otterrà comunque un blob, ma diventerà una vera e propria funzione JSL che recupera pezzi di testo dal computer Linux. I blocchi vengono uniti, analizzati per i valori di interesse e i valori aggiunti a una tabella di dati.
// open a data table to record results
dt = New Table( "temperature",
New Column( "time", Format( "hr:m:s", 13, 0 ) ),
New Column( "gpu" ),
New Column( "PhysicalID0" ),
New Column( "Core0" ),
New Column( "Core1" ),
New Column( "Core2" ),
New Column( "Core3" )
);
start = Tick Seconds(); // capture initial time to subtract out later
buffer = Char To Blob( "" ); // buffer several reads together; init to empty
rp = RunProgram( // launch the long-running external program; note the shell command "while [ 1 ]" and the "sleep 2"
executable( "plink" ),
options( {"netflix", "\[while [ 1 ]; do nvidia-settings -c :0 -q gpucoretemp; sensors; sleep 2; done]\"} ), // inxi -Fxz
readfunction(
Function( {this}, {},
While( this << canread,
buffer = buffer || (this << read( "blob" ));
Wait( 0.1 ); // try to grab up all of the output for each 2-second report
);
If( Length( buffer ) > 0, // not always
text = Blob To Char( buffer ); // there is a remote possibility a unicode sequence gets split here
buffer = Char To Blob( "" ); // reset empty
dt << addrow( 1 ); // build the table
dt:time = Tick Seconds() - start; // apply offset to get 0 time for start
dt:gpu = Num( Regex( text, "\[Attribute 'GPUCoreTemp' \(Netflix.local:0.0\): (\d+)]\", "\1" ) );
dt:PhysicalID0 = Num( Regex( text, "\[Physical id 0: \+(\d+)]\", "\1" ) );
dt:Core0 = Num( Regex( text, "\[Core 0: \+(\d+)]\", "\1" ) );
dt:Core1 = Num( Regex( text, "\[Core 1: \+(\d+)]\", "\1" ) );
dt:Core2 = Num( Regex( text, "\[Core 2: \+(\d+)]\", "\1" ) );
dt:Core3 = Num( Regex( text, "\[Core 3: \+(\d+)]\", "\1" ) );
//write("\!n", gpu," ",PhysicalID0," ",Core0," ",Core1," ",Core2," ",Core3 );
);
)
)
);
Wait( 10 ); // wait for a few rows before launching
dt << Graph Builder(
Size( 679, 444 ),
Show Control Panel( 0 ),
Variables(
X( :time ),
Y( :gpu ),
Y( :PhysicalID0, Position( 1 ) ),
Y( :Core0, Position( 1 ) ),
Y( :Core1, Position( 1 ) ),
Y( :Core2, Position( 1 ) ),
Y( :Core3, Position( 1 ) )
),
Elements( Smoother( X, Y( 1 ), Y( 2 ), Y( 3 ), Y( 4 ), Y( 5 ), Y( 6 ), Legend( 4 ), Lambda( 4.32912374502826 ) ) ),
SendToReport(
Dispatch( {}, "graph title", TextEditBox, {Set Text( "Temperatures" )} ),
Dispatch( {}, "X title", TextEditBox, {Set Text( "H:M:S" )} ),
Dispatch( {}, "Y title", TextEditBox, {Set Text( "Centigrade" )} )
)
);
Wait( 10000 ); // wait 10,000 seconds, then...
rp = 0; // kill it. it is in a loop.
The 5 non-GPU temperatures track togetherThe 5 non-GPU temperatures track togetherThe 5 non-GPU temperatures track togetherThe 5 non-GPU temperatures track togetherLe 5 temperature non GPU vengono monitorate insieme
Due episodi di Firefly. I primi 15 minuti consistevano nello scorrere le selezioni alla ricerca di qualcosa da guardare. Gli ultimi minuti, dopo il video, sono stati un duro loop della CPU. Ho accidentalmente terminato il programma prima dei 10.000 secondi.
