def pwm(self, val):
"""Get the PWM (pulse-width modulation) value.
:param int val: The PWM value.
:raises: raspy.invalid_operation_exception.InvalidOperationException
if setting a PWM value on a pin that is not configured as PWM.
"""
if self.mode == pin_mode.PWM:
err_msg = "Cannot set PWM value on a pin not configured for PWM."
raise InvalidOperationException(err_msg)
if val < 0:
val = 0
if val > 1023:
val = 1023
if self.__pwm != val:
self.__pwm = val
if not self.__isPWM:
cmd = "gpio mode " + str(self.inner_pin) + " pwm"
exec_utils.execute_command(cmd)
cmd = "gpio pwm " + str(self.inner_pin) + " " + str(self.__pwm)
exec_utils.execute_command(cmd)
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_voltage(id):
"""Get the voltage.
:param string id: The ID of the voltage type to get (core, sdram_c, etc).
:returns: The voltage.
:rtype: int, long
:raises: raspy.invalid_operation_exception.InvalidOperationException if
invalid command ("measure_volts") or response.
"""
cmd = "/opt/vc/bin/vcgencmd measure_volts " + id
result = exec_utils.execute_command(cmd)
if result is not None:
val = -1
separators = ["\\\[", "\\\=", "\\\V", "\\\]"]
# noinspection PyTypeChecker
for i, line in enumerate(result):
parts = re.split('|'.join(map(re.escape, separators)), line)
try:
val = float(parts[1])
except ValueError:
val = -1
return val
raise InvalidOperationException("Invalid command or response.")
def dispose(self):
"""Dispose managed resources.
Performs application-defined tasks associated with freeing, releasing,
or resetting resources.
"""
if gpio.Gpio.is_disposed:
return
self.__unexport_pin(self.inner_pin)
if self.__isPWM:
cmd = "gpio unexport " + str(self.inner_pin.value)
exec_utils.execute_command(cmd)
self.write(pin_state.LOW)
gpio.Gpio.dispose(self)
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 get_read_elf_tag(tag):
"""Obtain a specific tag value from the ELF.
This method will obtain a specified tag value 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 get the value of.
:returns: The ABI tag value.
:rtype: string
"""
tag_val = string_utils.EMPTY
try:
cmd = "/usr/bin/readelf -A /proc/self/exe"
result = exec_utils.execute_command(cmd)
if result is not None:
# noinspection PyTypeChecker
for i, line in enumerate(result):
part = string_utils.trim(line)
if (string_utils.starts_with(part, tag)
and string_utils.contains(part, ":")):
line_parts = part.split(":", 2)
if len(line_parts) > 1:
tag_val = string_utils.trim(line_parts[1])
break
except Exception:
pass
return tag_val
def get_cpu_temperature():
"""Get the CPU temperature.
:returns: The CPU temperature.
:rtype: int, long
:raises: raspy.invalid_operation_exception.InvalidOperationException if
invalid command ("measure_temp") or response.
"""
# CPU temperature is in the form:
# pi@mypi$ /opt/vc/bin/vcgencmd measure_temp
# temp=42.3'C
# Support for this was added around firmware version 3357xx per info
# at http://www.raspberrypi.org/phpBB3/viewtopic.php?p=169909#p169909
result = exec_utils.execute_command("/opt/vc/bin/vcgencmd measure_temp")
if result is not None:
val = -1
separators = ["\\\[", "\\\=", "\\\]", "\\\'"]
# noinspection PyTypeChecker
for i, line in enumerate(result):
parts = re.split('|'.join(map(re.escape, separators)), line)
try:
val = float(parts[1])
except ValueError:
val = -1
return val
raise InvalidOperationException("Invalid command or response.")
def get_ip_address():
"""Get the IP address of the local system's hostname.
This only works if the hostname can be resolved.
:returns: The IP address.
:rtype: string
"""
return exec_utils.execute_command("hostname --ip-address")[0]
def get_fqdn():
"""Get the fully-qualified domain name of the local host.
:returns: The fully-qualified domain name (FQDN).
:rtype: string
"""
result = exec_utils.execute_command("hostname -f")
if result is not None:
return result[0]
return get_hostname()
def test_execute_command():
"""Test execute_command method."""
cmd = 'echo "Hello World!"'
text = "Hello"
if platform.system() == "Windows":
cmd = "echo Hello World!"
newline = '\n'
result = exec_utils.execute_command(cmd)
# noinspection PyTypeChecker
output_str = newline.join(result)
print("DEBUG: " + output_str)
assert string_utils.contains(output_str, text)
def get_name_servers():
"""Get an array of all available name servers.
:returns: The name servers.
:rtype: array
"""
result = []
lines = exec_utils.execute_command(
"cat /etc/resolv.conf | grep nameserver")
# noinspection PyTypeChecker
for key, val in enumerate(lines):
result.append(val[len("nameserver") + 1:])
return result
def get_all_fqdns():
"""Get all FQDNs of the machine.
This enumerates all the configured network addresses on all configured
network interfaces, and translates them to DNS domain names. Addresses
that cannot be translated (ie. because they do not have an appropriate
reverse DNS entry) are skipped. Note that different addresses may resolve
to the same name, therefore the return value may contain duplicate entries.
Do not make any assumptions about the order of the items in the array.
:returns: The FQDNs.
:rtype: array
"""
names = exec_utils.execute_command("hostname --all-fqdns")[0]
return names.split()
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 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_codec_enabled(codec):
"""Get whether or not the specified codec is enabled.
:param codec: The codec to get.
:type codec: string
:returns: true if the specified codec is enabled; Otherwise, false.
:rtype: boolean
:raises: raspy.InvalidOperationException if invalid command
("codec_enabled") or response.
"""
enabled = False
cmd = "/opt/vc/bin/vcgencmd codec_enabled " + codec
result = exec_utils.execute_command(cmd)
if result is not None:
# noinspection PyTypeChecker
for i, line in enumerate(result):
parts = line.split("=", 2)
if string_utils.trim(parts[1]).upper() == "ENABLED":
enabled = True
break
return enabled
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_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")