code.fastix.org

Dateiansicht:

Datei:Projekte -> Linux, Python: CPU-Frequenz und Temperatur -> cpufreq.py
md5:591712e989bc2baf90bf1597233a08e4
sha1:161f0e8adec663597a83c76d8cbc204c31dc6ffc
Download-Link:Download
  1. #! /usr/bin/python3
  2.  
  3.  
  4. from pathlib import Path
  5. import math
  6.  
  7. class cpufreq:
  8.  
  9.         def __init__( self ):
  10.                 self._governor      = ''
  11.                 self._minfreq       = ''
  12.                 self._curfreq       = ''
  13.                 self._maxfreq       = ''
  14.                 self._calcstates    = ''
  15.                 self._sysruntime    = ''
  16.                 self._cpuTimefactor = 100
  17.                 self._hmFactor      = 1000000
  18.                 self._hmString      = 'GHz'
  19.                 self._tempFile      ='/sys/devices/virtual/thermal/thermal_zone0/temp'
  20.                 self._tempFaktor    = 0.001
  21.                 self._tempFormat    = '′C'
  22.                 if ( Path( '/sys/devices/system/cpu/cpu0/cpufreq/' ).is_dir() ) :
  23.                         self._path = '/sys/devices/system/cpu/cpu0/cpufreq/'
  24.                 elif ( Path( '/sys/devices/system/cpu/cpufreq/' ).is_dir() ):
  25.                         self._path = '/sys/devices/system/cpu/cpufreq/'
  26.                 self.read_from_system( );
  27.  
  28.         def read_the_line( self, fileName ):
  29.                 f = open( fileName, 'r' )
  30.                 l = f.read().strip()
  31.                 f.close()
  32.                 return l
  33.  
  34.         def human_readble( self, z ):
  35.                 z = z / self.hmFactor
  36.                 return '%0.3f %s'%( z, self._hmString )
  37.  
  38.         def Seconds2Human( self, s:int, daystring = 'd' ):
  39.                 s = int(s)
  40.                 # Days
  41.                 if ( s > 86400 ):
  42.                         d = math.floor( s / 86400 )
  43.                         s = s - d * 86400
  44.                 else:
  45.                         d = 0
  46.                
  47.                 # Houres
  48.                 if ( s > 3600 ):
  49.                         h = math.floor( s / 3600 )
  50.                         s = s - h * 3600
  51.                 else:
  52.                         h = 0
  53.                                
  54.                 # Minutes
  55.                 if ( s > 60 ):
  56.                         m = math.floor( s / 60 )
  57.                         s = s - m * 60
  58.                 else:
  59.                         m = 0
  60.                
  61.                 return '%d%s %02d:%02d:%02d'%( d, daystring, h, m, s )
  62.  
  63.         def read_from_system( self ):
  64.                 if ( Path( self._path + 'scaling_governor' ).exists() ):
  65.                         self._governor   =  self.read_the_line( self._path + 'scaling_governor' )
  66.                         self._minfreq    =  self.read_the_line( self._path + 'scaling_min_freq' )
  67.                         self._curfreq    =  self.read_the_line( self._path + 'scaling_cur_freq' )
  68.                         self._maxfreq    =  self.read_the_line( self._path + 'scaling_max_freq' )
  69.                 elif( Path( self._path + 'cpuinfo_min_freq' ).exists() ):
  70.                         self._governor   = false
  71.                         self._minfreq    = self.read_the_line( self._path + 'cpuinfo_min_freq' )
  72.                         self._maxfreq    = self.read_the_line( self._path + 'cpuinfo_max_freq' )
  73.  
  74.                         if ( Path( self._path + 'cpuinfo_curr_freq' ).exists() ):
  75.                                 self.curfreq = self.read_the_line( self._path + 'cpuinfo_cur_freq' )
  76.  
  77.                         elif ( self._maxfreq == self._minfreq ):
  78.                                 self._curfreq = self._minfreq
  79.  
  80.                         else:
  81.                                 self._curfreq = 0
  82.                 else:
  83.                         self._governor = false
  84.                         self._minfreq  = 0
  85.                         self._curfreq  = 0
  86.                         self._maxfreq  = self.read_the_line( self._path + 'cpuinfo_max_freq' )         
  87.  
  88.                 if ( Path( self._path + 'stats/time_in_state' ).exists() ):
  89.                         # self._calcstates = self.read_the_line( self._path + 'stats/time_in_state' )
  90.                         self._calcstates = self.readTimestates()
  91.  
  92.                 else:
  93.                         self._calcstates = false
  94.  
  95.         def human_readble ( self, z ):
  96.                 z = int(z) / self._hmFactor
  97.                 return '%0.3f %s' % ( z, self._hmString )
  98.  
  99.         def getFreq ( self, v, hm ):
  100.                 if ( hm ):
  101.                         return self.human_readble( v )
  102.                 else:
  103.                         return v
  104.  
  105.         def readTimestates( self ):
  106.                 f = open( self._path + 'stats/time_in_state' , 'r' )
  107.                 lines = f.readlines()
  108.                 f.close
  109.                 summe = 0
  110.                 arr = {}
  111.                 for line in lines:
  112.                         line = line.strip()
  113.                         if ( line ):
  114.                                 f, t =  line.split(' ')
  115.                                 t = math.floor( int(t) / self._cpuTimefactor )
  116.                                 d = {};
  117.                                 if ( t != 0 ):
  118.                                         summe += t
  119.                                         f = self.human_readble( f )
  120.                                         d['t_abs'] = t
  121.                                         d['t_hum'] = self.Seconds2Human( t )
  122.                                         arr[f] = d
  123.  
  124.                 self._sysruntime = summe;
  125.                                
  126.                 for f in arr.keys():
  127.                         arr[f]['t_rel'] = '%1.4f'%(round( arr[f]['t_abs'] / summe, 4 ) )
  128.                         arr[f]['t_100'] = '%5.1f%%' %( round( arr[f]['t_abs'] / summe * 100 , 1 ) )
  129.                 return arr
  130.  
  131.         def getMinFreq( self, hm = False ):
  132.                  return self.getFreq ( self._minfreq, hm )
  133.  
  134.         def getCurFreq( self, hm = False ):
  135.                  return self.getFreq ( self._curfreq, hm )
  136.  
  137.         def getMaxFreq( self, hm = False ):
  138.                  return self.getFreq ( self._maxfreq, hm );
  139.  
  140.         def getSysRunTime( self, hm = False ):
  141.                 if ( hm ):
  142.                         return self.Seconds2Human( self._sysruntime );
  143.                 else:
  144.                         return self._sysruntime;               
  145.  
  146.         def getCpuTemp ( self, hm = False ):
  147.                 t = float( self.read_the_line( self._tempFile ).strip() )
  148.                 t = t * self._tempFaktor;
  149.                 if ( hm ):
  150.                         return '%4.1f%s'%(round( t, 1 ), self._tempFormat);
  151.                 else:
  152.                         return t;
  153.        
  154.         def getCalcstates ( self ):
  155.                 return  self._calcstates;
  156.        
  157.         def getGovernor ( self ):
  158.                 return self._governor;
  159.  
  160.  
  161.    
  162.    
  163. ### main ###
  164.  
  165. import os
  166. if not os.environ.get('SHELL'):
  167.    
  168.     print ( 'Content-Type: text/plain; charset=utf-8' )
  169.     print ( 'Refresh: 1' )
  170.     print ()
  171.  
  172. cf = cpufreq()
  173. CurFreq = cf.getCurFreq( True )
  174.  
  175. print ('Governor:              ' , cf.getGovernor() )
  176. print ('Geringste Frequenz:    ' , cf.getMinFreq( True ) )
  177.  
  178. print ('Gegenwärtige Frequenz: ' , CurFreq , ' <' )
  179. print ('Maximale Frequenz:     ' , cf.getMaxFreq( True ) )
  180. print ('System läuft seit:     ' , cf.getSysRunTime( True ) )
  181.  
  182. a = cf.getCalcstates()
  183. if ( a ):
  184.        
  185.         print ( 'Zeitliche Frequenznutzung:' )
  186.         for freq in a.keys() :
  187.                 if ( freq == CurFreq ):
  188.                         LE = ' <'
  189.                 else:
  190.                         LE = ''
  191.                 print ( freq + ': ' , a[freq]['t_100'] , LE )
  192.  
  193. print ('Temperatur:' , cf.getCpuTemp( True ) )
  194. print()
  195.