def get_cpu_info(target):
"""Get information about the CPU.
Returns the value from the specified target field.
:param string target: The target attribute to the value of.
:returns: The value of the specified CPU attribute.
:rtype: string
:raises: raspy.invalid_operation_exception.InvalidOperationException if
the specified target is invalid (unknown).
"""
global __cpuInfo
if __cpuInfo is None:
__cpuInfo = []
result = exec_utils.execute_command("cat /proc/cpuinfo")
if result is not None:
# noinspection PyTypeChecker
for key, val in enumerate(result):
line = val
parts = line.split(":")
if len(parts) >= 2:
tpart0 = string_utils.trim(parts[0])
tpart1 = string_utils.trim(parts[1])
if (not string_utils.is_null_or_empty(tpart0)
and not string_utils.is_null_or_empty(tpart1)):
# noinspection PyTypeChecker
__cpuInfo[tpart0] = tpart1
if target in __cpuInfo:
# noinspection PyTypeChecker
return __cpuInfo[target]
raise InvalidOperationException("Invalid target: " + target)
def get_clock_frequency(target):
"""Get the clock frequency for the specified target.
:param string target: The target clock to get the frequency of.
:returns: The clock frequency, if successful; Otherwise, -1.
:rtype: int, long
"""
if string_utils.is_null_or_empty(target):
return -1
target = string_utils.trim(target)
val = -1
cmd = "/opt/vc/bin/vcgencmd measure_clock " + target
result = exec_utils.execute_command(cmd)
if result is not None:
# noinspection PyTypeChecker
for i, line in enumerate(result):
parts = line.split("=", 2)
try:
temp = float(string_utils.trim(parts[1]))
except ValueError:
temp = -1
if temp != -1:
val = temp
break
return val
def __str__(self):
"""Return the string representation of this class instance.
:returns: The string representation of this class.
:rtype: str
"""
base = Component.component_name.fget()
if not string_utils.is_null_or_empty(base):
return base
return self.__class__.__name__
def get_scale_postfix(scale):
"""Get the scale postfix.
:param int scale: The scale to get the postfix for.
:returns: The scale postfix or an empty string if the specified scale is
invalid or unknown.
:rtype: str
"""
name = get_scale_name(scale)
if string_utils.is_null_or_empty(name):
return string_utils.EMPTY
return name[0]
def has_read_elf_tag(tag):
"""Determine if a specified tag exists from the ELF.
This method will determine if a specified tag exists from the ELF info in
the '/proc/self/exe' program (this method is used to help determine the
HARD-FLOAT / SOFT-FLOAT ABI of the system).
:param string tag: The tag to check for.
:returns: True if contains the specified ELF tag.
:rtype: boolean
"""
tag_val = get_read_elf_tag(tag)
return not string_utils.is_null_or_empty(tag_val)
def __init__(self, file_path):
"""Initialize a new instance of raspy.io.file_info.FileInfo.
Initializes a new instance of the FileInfo class with the
fully-qualified or relative name of the file.
:param str file_path: The fully-qualified name of the of the file,
or the relative file name.
:raises: raspy.argument_null_exception.ArgumentNullException if
file_path is null or an empty string.
"""
if string_utils.is_null_or_empty(file_path):
raise ArgumentNullException(
"'file_path' param cannot be null or " + "undefined.")
self.__name = os.path.basename(file_path)
self.__originalPath = file_path
self.__fullPath = os.path.normpath(self.__originalPath)
def get_bash_version_info():
"""Get the BaSH version info.
This method is used to help determine the HARD_FLOAT / SOFT_FLOAT ABI of
the system.
:returns: The BaSH version info.
:rtype: string
"""
ver = string_utils.EMPTY
try:
result = exec_utils.execute_command("bash --version")
# noinspection PyTypeChecker
for i, line in enumerate(result):
if not string_utils.is_null_or_empty(line):
ver = line # Return only the first line.
break
except Exception:
pass
return ver
def get_memory():
"""Get the system memory info.
:returns: The memory info.
:rtype: array
"""
values = []
result = exec_utils.execute_command("free -b")
if result is not None:
val = 0
# noinspection PyTypeChecker
for i, line in enumerate(result):
if string_utils.starts_with(line, "Mem:"):
parts = line.split()
for j, part in enumerate(parts):
line_part = string_utils.trim(part)
if (not string_utils.is_null_or_empty(line_part)
and line.upper() == "Mem:".upper()):
values.append(float(val))
return values
def get_os_firmware_date():
"""Get the OS firmware date.
:returns: The OS firmware date.
:rtype: string
:raises: raspy.invalid_operation_exception.InvalidOperationException if
an unexpected response is received.
"""
results = exec_utils.execute_command("/opt/vc/bin/vcgencmd version")
val = string_utils.EMPTY
if results is not None:
# noinspection PyTypeChecker
for key, value in enumerate(results):
# We are intentionally only getting the first line.
val = value
break
if not string_utils.is_null_or_empty(val):
return val
raise InvalidOperationException("Invalid command or response.")
def set_display_to_string(self, string, dots=False, pos=0):
"""Set the display to the specified string.
:param string string: The string to set the display to.
:param bool dots: Set True to turn on dots.
:param byte, int pos: The character position to start the string at.
"""
if string_utils.is_null_or_empty(string):
self.clear_display()
return
global C_MAP
length = len(string)
for i in range(0, self.__displays - 1):
if i < length:
l_pos = i + pos
l_data = C_MAP[string[i]]
l_dot = (dots & (1 << (self.__displays - i - 1))) != 0
self.send_char(l_pos, l_data, l_dot)
else:
break
def get_os_firmware_build():
"""Get the OS firmware build.
:returns: the OS firmware build.
:rtype: string
:raises: raspy.invalid_operation_exception.InvalidOperationException if
an unexpected response is received.
"""
results = exec_utils.execute_command("/opt/vc/bin/vcgencmd version")
val = string_utils.EMPTY
if results is not None:
# noinspection PyTypeChecker
for key, val in enumerate(results):
line = val
if string_utils.starts_with(line, "version "):
val = line
break
if not string_utils.is_null_or_empty(val):
return val[8:]
raise InvalidOperationException("Invalid command or response")
def create_output_pin(pin, name):
"""Factory method for creating a PiFace digital output pin.
:param raspy.io.pi_face_pins.PiFacePin pin: The pin to create an output
for.
:param str name: The name of the pin. If not specified, the default
hardware name of the pin will be used instead.
:returns: A PiFace digital output.
:rtype: raspy.io.pi_face_gpio_digital.PiFaceGpioDigital
:raises: raspy.io.io_exception.IOException if unable to communicate with
the SPI bus.
"""
if string_utils.is_null_or_empty(name):
name = pin.name
val = pin.value
speed = PiFaceGpioDigital.BUS_SPEED
pfgd = PiFaceGpioDigital(pin, pin_state.LOW, val, speed)
pfgd.pin_name = name
pfgd.mode = pin_mode.OUT
pfgd.pull_resistance = pin_pull_resistance.Off
return pfgd
def __init__(self, pn, initial_val, name):
"""Initialize a new instance of the raspy.io.PiFaceGPIO class.
:param raspy.io.pi_face_pin.PiFacePin pn: The underlying PiFace pin.
:param int initial_val: The initial pin value (state).
:param string name: The pin name.
:raises: raspy.argument_null_exception.ArgumentNullException if the
specified pin is NonePin.
:raises: raspy.illegal_argument_exception.IllegalArgumentException if
the specified pin is not of type raspy.io.pi_face_pins.PiFacePin.
"""
gpio.Gpio.__init__(self, pn, pin_mode.IN, initial_val)
self.__pwm = 0
self.__pwmRange = 0
if pn is None:
raise ArgumentNullException("pn param cannot be NonePin.")
if not isinstance(pn, pi_face_pins.PiFacePin):
err_msg = "pn param must be a PiFacePins member."
raise IllegalArgumentException(err_msg)
self.pin_name = name
if string_utils.is_null_or_empty(self.pin_name):
self.pin_name = pn.name
if (pn == pi_face_pins.Input00 or pn == pi_face_pins.Input01
or pn == pi_face_pins.Input02 or pn == pi_face_pins.Input03
or pn == pi_face_pins.Input04 or pn == pi_face_pins.Input05
or pn == pi_face_pins.Input06 or pn == pi_face_pins.Input07):
self.mode = pin_mode.IN
elif (pn == pi_face_pins.Output00 or pn == pi_face_pins.Output01
or pn == pi_face_pins.Output02 or pn == pi_face_pins.Output03
or pn == pi_face_pins.Output04 or pn == pi_face_pins.Output05
or pn == pi_face_pins.Output06 or pn == pi_face_pins.Output07):
self.mode = pin_mode.OUT
def execute_command(command):
"""Execute the specified command.
Executes the specified command and returns the output.
:param command: The command to execute.
:type command: str
:returns: A string array containing each line of the output.
:rtype: list
"""
if string_utils.is_null_or_empty(command):
return []
args = string_utils.EMPTY
cmd_line = command.split(" ")
if len(cmd_line) > 1:
command = cmd_line[0]
for i in range(1, len(cmd_line)):
args += cmd_line[i] + " "
if string_utils.ends_with(args, " "):
args = args[0:len(args) - 1]
result = []
cmd = [command] + args.split(" ")
cmd_spawn = Popen(cmd, stdout=PIPE, stderr=PIPE)
output, err = cmd_spawn.communicate()
if cmd_spawn.returncode == 0:
for line in output.strip().split("\n"):
result.append(line)
if err:
# TODO should we do anything with this? # pylint: disable=fixme
pass
return result
def test_is_null_or_empty():
"""Test is_null_or_empty method."""
assert string_utils.is_null_or_empty(None)
assert string_utils.is_null_or_empty(string_utils.EMPTY)