sys-cpu 0.6.4-universal-mingw32

data/ext/version.h

@@ -0,0 +1,2 @@
+/* version.h - one version to rule them all */
+#define SYS_CPU_VERSION "0.6.4"

data/install.rb

@@ -0,0 +1,85 @@
+#######################################################################
+# install.rb
+#
+# For pure Ruby versions only. Generally speaking this script should
+# not be run directly. Use the 'rake install' task instead.
+#######################################################################
+require 'rbconfig'
+require 'fileutils'
+include Config
+install_dir = File.join(CONFIG['sitelibdir'], 'sys')
+
+file = ""
+
+case CONFIG['host_os']
+  when /windows|win32|mingw|cygwin|dos/i
+    file = "lib/windows/sys/cpu.rb"
+  when /linux/i
+    file = "lib/linux/sys/cpu.rb"
+  when /sunos|solaris|hpux|freebsd/i
+    STDERR.puts "Use 'extconf.rb/make/make site-install' for this platform"
+    exit
+  else
+    STDERR.puts "This platform is not currently supported.  Exiting..."
+    exit
+end
+
+#######################################################################
+# Dynamically generate some of the documentation for linux.  If the
+# doc size is already greater than 1.4k, assume that the documentation
+# has already been written at some point previously and skip it.
+#######################################################################
+if CONFIG['host_os'] =~ /linux/
+  cpu_file  = "/proc/cpuinfo"
+  text_file = "doc/linux.txt"
+  rb_file   = "lib/linux/sys/cpu.rb"
+
+  if File.size(text_file) > 1400
+    puts "You appear to have already created the documentation."
+    puts "Skipping..."
+  else
+    puts "Dynamically generating documentation..."
+    fh = File.open(text_file, 'a')
+
+    IO.foreach(cpu_file){ |line|
+      next if line =~ /^$/
+      k,v = line.split(":")
+         
+      v = v.strip.chomp
+      k = k.strip.gsub(/\s+/, '_').downcase
+
+      k += "?" if v =~ /yes|no/i
+
+      fh.puts("CPU.#{k}")
+
+      if v =~ /yes|no/i
+        k.chop!
+        msg = "     Returns true if a " + k.gsub(/_/," ") + "exists on"
+        msg << " this system"
+        fh.puts(msg)
+      else
+        fh.puts("     Returns the " + k.gsub(/_/," "))
+      end
+
+      fh.puts # Add a blank line
+    }
+
+    fh.close
+    puts "Documentation creation complete"
+  end
+end
+
+# Create the 'sys' toplevel directory if it doesn't already exist
+begin
+  unless File.exist?(install_dir)
+    Dir.mkdir(install_dir)
+  end
+rescue Errno::EACCES => e
+  puts "Unable to create #{install_dir}: #{e}"
+  exit
+end
+
+# Finally, copy the file to the appropriate directory
+FileUtils.cp(file, "#{install_dir}/cpu.rb", :verbose => true)
+
+puts "Installation successful"

data/lib/linux/sys/cpu.rb

@@ -0,0 +1,122 @@
+##########################################################
+# linux.rb (sys-cpu) - pure Ruby version for Linux
+##########################################################
+module Sys
+
+  # :stopdoc:
+
+  cpu_file   = "/proc/cpuinfo"
+  cpu_hash   = {}
+  $cpu_array = []
+
+  # Parse the info out of the /proc/cpuinfo file
+  IO.foreach(cpu_file){ |line|
+    line.strip!
+    next if line.empty?
+
+    key, val = line.split(":")
+    key.strip!
+    key.gsub!(/\s+/,"_")
+    key.downcase!
+    val.strip! if val
+
+    if cpu_hash.has_key?(key)
+      $cpu_array.push(cpu_hash.dup)
+      cpu_hash.clear
+    end
+
+    # Turn yes/no attributes into booleans
+    if val == 'yes'
+      val = true
+    elsif val == 'no'
+      val = false
+    end
+
+    cpu_hash[key] = val
+  }
+
+  $cpu_array.push(cpu_hash)
+
+  # :startdoc:
+
+  class CPU
+
+    # The version of the sys-cpu library.
+    VERSION = '0.6.4'
+
+    # :stopdoc:
+
+    CPUStruct = Struct.new("CPUStruct", *$cpu_array.first.keys)
+
+    # :startdoc:
+
+    # In block form, yields a CPUStruct for each CPU on the system.  In
+    # non-block form, returns an Array of CPUStruct's.
+    #
+    # The exact members of the struct vary on Linux systems.
+    #
+    def self.processors
+      array = []
+      $cpu_array.each{ |hash|
+        struct = CPUStruct.new
+        struct.members.each{ |m| struct.send("#{m}=", hash[m]) }
+        if block_given?
+          yield struct
+        else
+          array << struct
+        end
+      }
+      array unless block_given?
+    end
+
+    private
+
+    # Create singleton methods for each of the attributes.
+    #
+    def self.method_missing(id, arg=0)
+      rv = $cpu_array[arg][id.to_s]
+      if rv.nil?
+        id = id.to_s + "?"
+        rv = $cpu_array[arg][id]
+      end
+      rv
+    end
+
+    public
+
+    # Returns a 3 element Array corresponding to the 1, 5 and 15 minute
+    # load average for the system.
+    #
+    def self.load_avg
+      load_avg_file = "/proc/loadavg"
+      IO.readlines(load_avg_file).first.split[0..2].map{ |e| e.to_f }
+    end
+
+    # Returns a hash of arrays that contain the number of seconds that the
+    # system spent in user mode, user mode with low priority (nice), system
+    # mode, and the idle task, respectively.
+    #
+    def self.cpu_stats
+      cpu_stat_file = "/proc/stat"
+      hash = {} # Hash needed for multi-cpu systems
+
+      lines = IO.readlines(cpu_stat_file)
+
+      lines.each_with_index{ |line, i|
+        array = line.split
+        break unless array[0] =~ /cpu/   # 'cpu' entries always on top
+
+        # Some machines list a 'cpu' and a 'cpu0'. In this case only
+        # return values for the numbered cpu entry.
+        if lines[i].split[0] == "cpu" && lines[i+1].split[0] =~ /cpu\d/
+          next
+        end
+
+        vals = array[1..-1].map{ |e| e = e.to_i / 100 } # 100 jiffies/sec.
+        hash[array[0]] = vals
+      }
+
+      hash
+    end
+  end
+end

data/lib/windows/sys/cpu.rb

@@ -0,0 +1,790 @@
+require 'win32ole'
+require 'socket'
+
+# The Sys module serves only as a namespace
+module Sys
+  # Encapsulates system CPU information
+  class CPU
+    # Error raised if any of the Sys::CPU methods fail.
+    class Error < StandardError; end
+
+    # The version of the sys-cpu library
+    VERSION = '0.6.4'
+
+    private
+
+    # Base connect string
+    BASE_CS = "winmgmts:{impersonationLevel=impersonate}" # :nodoc:
+
+    # Fields used in the CPUStruct
+    fields = %w/
+      address_width
+      architecture
+      availability
+      caption
+      config_manager_error_code
+      config_manager_user_config
+      cpu_status
+      creation_class_name
+      freq
+      voltage
+      data_width
+      description
+      device_id
+      error_cleared?
+      error_description
+      ext_clock
+      family
+      install_date
+      l2_cache_size
+      l2_cache_speed
+      last_error_code
+      level
+      load_avg
+      manufacturer
+      max_clock_speed
+      name
+      other_family_description
+      pnp_device_id
+      power_management_supported?
+      power_management_capabilities
+      processor_id
+      processor_type
+      revision
+      role
+      socket_designation
+      status
+      status_info
+      stepping
+      system_creation_class_name
+      system_name
+      unique_id
+      upgrade_method
+      version
+      voltage_caps
+    /
+
+    # The struct returned by the CPU.processors method
+    CPUStruct = Struct.new("CPUStruct", *fields) # :nodoc:
+
+    public
+
+    # Returns the +host+ CPU's architecture, or nil if it cannot be
+    # determined.
+    #
+    def self.architecture(host=Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        self.get_cpu_arch(wmi.Architecture)
+      end
+    end
+
+    # Returns an integer indicating the speed (i.e. frequency in Mhz) of
+    # +cpu_num+ on +host+, or the localhost if no +host+ is specified.
+    # If +cpu_num+ +1 is greater than the number of cpu's on your system
+    # or this call fails for any other reason, a Error is raised.
+    #
+    def self.freq(cpu_num = 0, host = Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        return wmi.CurrentClockSpeed
+      end
+    end
+
+    # Returns the load capacity for +cpu_num+ on +host+, or the localhost
+    # if no host is specified, averaged to the last second. Processor
+    # loading refers to the total computing burden for each processor at
+    # one time.
+    #
+    # Note that this attribute is actually the LoadPercentage.  I may use
+    # one of the Win32_Perf* classes in the future.
+    #
+    def self.load_avg(cpu_num = 0, host = Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        return wmi.LoadPercentage
+      end
+    end
+
+    # Returns a string indicating the cpu model, e.g. Intel Pentium 4.
+    #
+    def self.model(host = Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        return wmi.Name
+      end
+    end
+
+    # Returns an integer indicating the number of cpu's on the system.
+    #--
+    # This (oddly) requires a different class.
+    #
+    def self.num_cpu(host = Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_ComputerSystem='#{host}'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        return wmi.NumberOfProcessors
+      end
+    end
+
+    # Returns a CPUStruct for each CPU on +host+, or the localhost if no
+    # +host+ is specified.  A CPUStruct contains the following members:
+    #
+    # * address_width
+    # * architecture
+    # * availability
+    # * caption
+    # * config_manager_error_code
+    # * config_manager_user_config
+    # * cpu_status
+    # * creation_class_name
+    # * freq
+    # * voltage
+    # * data_width
+    # * description
+    # * device_id
+    # * error_cleared?
+    # * error_description
+    # * ext_clock
+    # * family
+    # * install_date
+    # * l2_cache_size
+    # * l2_cache_speed
+    # * last_error_code
+    # * level
+    # * load_avg
+    # * manufacturer
+    # * max_clock_speed
+    # * name
+    # * other_family_description
+    # * pnp_device_id
+    # * power_management_supported?
+    # * power_management_capabilities
+    # * processor_id
+    # * processor_type
+    # * revision
+    # * role
+    # * socket_designation
+    # * status
+    # * status_info
+    # * stepping
+    # * system_creation_class_name
+    # * system_name
+    # * unique_id
+    # * upgrade_method
+    # * version
+    # * voltage_caps
+    #
+    # Note that not all of these members will necessarily be defined.
+    #
+    def self.processors(host = Socket.gethostname) # :yields: CPUStruct
+      begin
+        wmi = WIN32OLE.connect(BASE_CS + "//#{host}/root/cimv2")
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        wmi.InstancesOf("Win32_Processor").each{ |cpu|
+          yield CPUStruct.new(
+            cpu.AddressWidth,
+            self.get_cpu_arch(cpu.Architecture),
+            self.get_availability(cpu.Availability),
+            cpu.Caption,
+            self.get_cmec(cpu.ConfigManagerErrorCode),
+            cpu.ConfigManagerUserConfig,
+            get_status(cpu.CpuStatus),
+            cpu.CreationClassName,
+            cpu.CurrentClockSpeed,
+            cpu.CurrentVoltage,
+            cpu.DataWidth,
+            cpu.Description,
+            cpu.DeviceId,
+            cpu.ErrorCleared,
+            cpu.ErrorDescription,
+            cpu.ExtClock,
+            self.get_family(cpu.Family),
+            cpu.InstallDate,
+            cpu.L2CacheSize,
+            cpu.L2CacheSpeed,
+            cpu.LastErrorCode,
+            cpu.Level,
+            cpu.LoadPercentage,
+            cpu.Manufacturer,
+            cpu.MaxClockSpeed,
+            cpu.Name,
+            cpu.OtherFamilyDescription,
+            cpu.PNPDeviceID,
+            cpu.PowerManagementSupported,
+            cpu.PowerManagementCapabilities,
+            cpu.ProcessorId,
+            self.get_processor_type(cpu.ProcessorType),
+            cpu.Revision,
+            cpu.Role,
+            cpu.SocketDesignation,
+            cpu.Status,
+            cpu.StatusInfo,
+            cpu.Stepping,
+            cpu.SystemCreationClassName,
+            cpu.SystemName,
+            cpu.UniqueId,
+            self.get_upgrade_method(cpu.UpgradeMethod),
+            cpu.Version,
+            self.get_voltage_caps(cpu.VoltageCaps)
+          )
+        }
+      end
+    end
+
+    # Returns a string indicating the type of processor, e.g. GenuineIntel.
+    #
+    def self.type(host = Socket.gethostname)
+      cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"
+      begin
+        wmi = WIN32OLE.connect(cs)
+      rescue WIN32OLERuntimeError => e
+        raise Error, e
+      else
+        return wmi.Manufacturer
+      end
+    end
+
+    private
+
+    # Convert the ConfigManagerErrorCode number to its corresponding string
+    # Note that this value returns nil on my system.
+    #
+    def self.get_cmec(num)
+      case
+        when 0
+          str = "The device is working properly."
+          return str
+        when 1
+          str = "The device is not configured correctly."
+          return str
+        when 2
+          str = "Windows cannot load the driver for the device."
+          return str
+        when 3
+          str = "The driver for the device might be corrupted, or the"
+          str << " system may be running low on memory or other"
+          str << " resources."
+          return str
+        when 4
+          str = "The device is not working properly. One of the drivers"
+          str << " or the registry might be corrupted."
+          return str
+        when 5
+          str = "The driver for this device needs a resource that"
+          str << " Windows cannot manage."
+          return str
+        when 6
+          str = "The boot configuration for this device conflicts with"
+          str << " other devices."
+          return str
+        when 7
+          str = "Cannot filter."
+          return str
+        when 8
+          str = "The driver loader for the device is missing."
+          return str
+        when 9
+          str = "This device is not working properly because the"
+          str << " controlling firmware is reporting the resources"
+          str << " for the device incorrectly."
+          return str
+        when 10
+          str = "This device cannot start."
+          return str
+        when 11
+          str = "This device failed."
+          return str
+        when 12
+          str = "This device cannot find enough free resources that"
+          str << " it can use."
+          return str
+        when 13
+          str = "Windows cannot verify this device's resources."
+          return str
+        when 14
+          str = "This device cannot work properly until you restart"
+          str << " your computer."
+          return str
+        when 15
+          str = "This device is not working properly because there is"
+          str << " probably a re-enumeration problem."
+          return str
+        when 16
+           str = "Windows cannot identify all the resources this device "
+           str << " uses."
+           return str
+        when 17
+          str = "This device is asking for an unknown resource type."
+          return str
+        when 18
+          str = "Reinstall the drivers for this device."
+          return str
+        when 19
+          str = "Failure using the VXD loader."
+          return str
+        when 20
+          str = "Your registry might be corrupted."
+          return str
+        when 21
+          str = "System failure: try changing the driver for this device."
+          str << " If that does not work, see your hardware documentation."
+          str << " Windows is removing this device."
+          return str
+        when 22
+          str = "This device is disabled."
+          return str
+        when 23
+          str = "System failure: try changing the driver for this device."
+          str << "If that doesn't work, see your hardware documentation."
+          return str
+        when 24
+          str = "This device is not present, not working properly, or"
+          str << " does not have all its drivers installed."
+          return str
+        when 25
+          str = "Windows is still setting up this device."
+          return str
+        when 26
+          str = "Windows is still setting up this device."
+          return str
+        when 27
+          str = "This device does not have valid log configuration."
+          return str
+        when 28
+          str = "The drivers for this device are not installed."
+          return str
+        when 29
+          str = "This device is disabled because the firmware of the"
+          str << " device did not give it the required resources."
+          return str
+        when 30
+          str = "This device is using an Interrupt Request (IRQ)"
+          str << " resource that another device is using."
+          return str
+        when 31
+          str = "This device is not working properly because Windows"
+          str << " cannot load the drivers required for this device"
+          return str
+        else
+          return nil
+      end
+    end
+
+    # Convert an cpu architecture number to a string
+    def self.get_cpu_arch(num)
+      case num
+        when 0
+          return "x86"
+        when 1
+          return "MIPS"
+        when 2
+          return "Alpha"
+        when 3
+          return "PowerPC"
+        when 6
+          return "IA64"
+        when 9
+          return "x64"
+        else
+          return nil
+      end
+    end
+
+    # convert an Availability number into a string
+    def self.get_availability(num)
+      case num
+        when 1
+          return "Other"
+        when 2
+          return "Unknown"
+        when 3
+          return "Running"
+        when 4
+          return "Warning"
+        when 5
+          return "In Test"
+        when 6
+          return "Not Applicable"
+        when 7
+          return "Power Off"
+        when 8
+          return "Off Line"
+        when 9
+          return "Off Duty"
+        when 10
+          return "Degraded"
+        when 11
+          return "Not Installed"
+        when 12
+          return "Install Error"
+        when 13
+          return "Power Save - Unknown"
+        when 14
+          return "Power Save - Low Power Mode"
+        when 15
+          return "Power Save - Standby"
+        when 16
+          return "Power Cycle"
+        when 17
+          return "Power Save - Warning"
+        when 18
+          return "Paused"
+        when 19
+          return "Not Ready"
+        when 20
+          return "Not Configured"
+        when 21
+          return "Quiesced"
+        else
+          return nil
+      end
+    end
+
+    # convert CpuStatus to a string form.  Note that values 5 and 6 are
+    # skipped because they're reserved.
+    def self.get_status(num)
+      case num
+        when 0
+          return "Unknown"
+        when 1
+          return "Enabled"
+        when 2
+          return "Disabled by User via BIOS Setup"
+        when 3
+          return "Disabled By BIOS (POST Error)"
+        when 4
+          return "Idle"
+        when 7
+          return "Other"
+        else
+          return nil
+      end
+    end
+
+    # Convert a family number into the equivalent string
+    def self.get_family(num)
+      case num
+        when 1
+          return "Other"
+        when 2
+          return "Unknown"
+        when 3
+          return "8086"
+        when 4
+          return "80286"
+        when 5
+          return "80386"
+        when 6
+          return "80486"
+        when 7
+          return "8087"
+        when 8
+          return "80287"
+        when 9
+          return "80387"
+        when 10
+          return "80487"
+        when 11
+          return "Pentium?"
+        when 12
+          return "Pentium?"
+        when 13
+          return "Pentium?"
+        when 14
+          return "Pentium?"
+        when 15
+          return "Celeron?"
+        when 16
+          return "Pentium?"
+        when 17
+          return "Pentium?"
+        when 18
+          return "M1"
+        when 19
+          return "M2"
+        when 24
+          return "K5"
+        when 25
+          return "K6"
+        when 26
+          return "K6-2"
+        when 27
+          return "K6-3"
+        when 28
+          return "AMD"
+        when 29
+          return "AMD?"
+        when 30
+          return "AMD2900"
+        when 31
+          return "K6-2+"
+        when 32
+          return "Power"
+        when 33
+          return "Power"
+        when 34
+          return "Power"
+        when 35
+          return "Power"
+        when 36
+          return "Power"
+        when 37
+          return "Power"
+        when 38
+          return "Power"
+        when 39
+          return "Power"
+        when 48
+          return "Alpha"
+        when 49
+          return "Alpha"
+        when 50
+          return "Alpha"
+        when 51
+          return "Alpha"
+        when 52
+          return "Alpha"
+        when 53
+          return "Alpha"
+        when 54
+          return "Alpha"
+        when 55
+          return "Alpha"
+        when 64
+          return "MIPS"
+        when 65
+          return "MIPS"
+        when 66
+          return "MIPS"
+        when 67
+          return "MIPS"
+        when 68
+          return "MIPS"
+        when 69
+          return "MIPS"
+        when 80
+          return "SPARC"
+        when 81
+          return "SuperSPARC"
+        when 82
+          return "microSPARC"
+        when 83
+          return "microSPARC"
+        when 84
+          return "UltraSPARC"
+        when 85
+          return "UltraSPARC"
+        when 86
+          return "UltraSPARC"
+        when 87
+          return "UltraSPARC"
+        when 88
+          return "UltraSPARC"
+        when 96
+          return "68040"
+        when 97
+          return "68xxx"
+        when 98
+          return "68000"
+        when 99
+          return "68010"
+        when 100
+          return "68020"
+        when 101
+          return "68030"
+        when 112
+          return "Hobbit"
+        when 120
+          return "Crusoe?"
+        when 121
+          return "Crusoe?"
+        when 128
+          return "Weitek"
+        when 130
+          return "Itanium?"
+        when 144
+          return "PA-RISC"
+        when 145
+          return "PA-RISC"
+        when 146
+          return "PA-RISC"
+        when 147
+          return "PA-RISC"
+        when 148
+          return "PA-RISC"
+        when 149
+          return "PA-RISC"
+        when 150
+          return "PA-RISC"
+        when 160
+          return "V30"
+        when 176
+          return "Pentium?"
+        when 177
+          return "Pentium?"
+        when 178
+          return "Pentium?"
+        when 179
+          return "Intel?"
+        when 180
+          return "AS400"
+        when 181
+          return "Intel?"
+        when 182
+          return "AMD"
+        when 183
+          return "AMD"
+        when 184
+          return "Intel?"
+        when 185
+          return "AMD"
+        when 190
+          return "K7"
+        when 200
+          return "IBM390"
+        when 201
+          return "G4"
+        when 202
+          return "G5"
+        when 250
+          return "i860"
+        when 251
+          return "i960"
+        when 260
+          return "SH-3"
+        when 261
+          return "SH-4"
+        when 280
+          return "ARM"
+        when 281
+          return "StrongARM"
+        when 300
+          return "6x86"
+        when 301
+          return "MediaGX"
+        when 302
+          return "MII"
+        when 320
+          return "WinChip"
+        when 350
+          return "DSP"
+        when 500
+          return "Video"
+        else
+          return nil
+      end
+    end
+
+    # Convert power management capabilities number to its equivalent string
+    def self.get_pmc(num)
+      case num
+        when 0
+          return "Unknown"
+        when 1
+          return "Not Supported"
+        when 2
+          return "Disabled"
+        when 3
+          return "Enabled"
+        when 4
+          return "Power Saving Modes Entered Automatically"
+        when 5
+          return "Power State Settable"
+        when 6
+          return "Power Cycling Supported"
+        when 7
+          return "Timed Power On Supported"
+        else
+          return nil
+      end
+    end
+
+    # Convert a processor type into its equivalent string
+    def self.get_processor_type(num)
+      case num
+        when 1
+          return "Other"
+        when 2
+          return "Unknown"
+        when 3
+          return "Central Processor"
+        when 4
+          return "Math Processor"
+        when 5
+          return "DSP Processor"
+        when 6
+          return "Video Processor"
+        else
+          return nil
+      end
+    end
+
+    # Convert an upgrade method into its equivalent string
+    def self.get_upgrade_method(num)
+      case num
+        when 1
+          return "Other"
+        when 2
+          return "Unknown"
+        when 3
+          return "Daughter Board"
+        when 4
+          return "ZIF Socket"
+        when 5
+          return "Replacement/Piggy Back"
+        when 6
+          return "None"
+        when 7
+          return "LIF Socket"
+        when 8
+          return "Slot 1"
+        when 9
+          return "Slot 2"
+        when 10
+          return "370 Pin Socket"
+        when 11
+          return "Slot A"
+        when 12
+          return "Slot M"
+        else
+          return nil
+      end
+    end
+
+    # Convert return values to voltage cap values (floats)
+    def self.get_voltage_caps(num)
+      case num
+        when 1
+          return 5.0
+        when 2
+          return 3.3
+        when 4
+          return 2.9
+        else
+          return nil
+      end
+    end
+  end
+end