+# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""
+Much code from https://github.com/vsergeev/python-periphery/blob/master/periphery/pwm.py
+Copyright (c) 2015-2016 vsergeev / Ivan (Vanya) A. Sergeev
+License: MIT
+"""
+
import os
from time import sleep
from errno import EACCES
raise RuntimeError("No PWM outputs defined for this board.") from ImportError
+# pylint: disable=unnecessary-pass, too-many-instance-attributes
+
+
class PWMError(IOError):
"""Base class for PWM errors."""
pass
+# pylint: enable=unnecessary-pass
+
+
class PWMOut:
"""Pulse Width Modulation Output Class"""
PWM_STAT_DELAY = 0.1
# Sysfs paths
- _sysfs_path = "/sys/class/pwm"
_chip_path = "pwmchip{}"
_channel_path = "pwm{}"
- # Sysfs commands
- _export = "export"
- _unexport = "unexport"
-
- # Pin commands
- _pin_period = "period"
- _pin_duty_cycle = "duty_cycle"
- _pin_polarity = "polarity"
- _pin_enable = "enable"
-
def __init__(self, pwm, *, frequency=500, duty_cycle=0, variable_frequency=False):
"""Instantiate a PWM object and open the sysfs PWM corresponding to the
specified chip and channel.
self._chip = pwmout[0][0]
self._channel = pwmout[0][1]
- self._pwm = pwm
-
self._chip_path = os.path.join(
- self._sysfs_path, self._chip_path.format(self._chip)
+ "/sys/class/pwm", self._chip_path.format(self._chip)
)
self._channel_path = os.path.join(
self._chip_path, self._channel_path.format(self._channel)
)
+ if variable_frequency:
+ print("Variable Frequency is not supported, continuing without it...")
+
if not os.path.isdir(self._chip_path):
raise LookupError("Opening PWM: PWM chip {} not found.".format(self._chip))
if not os.path.isdir(self._channel_path):
# Exporting the PWM.
try:
- with open(os.path.join(self._chip_path, self._export), "w") as f_export:
+ with open(
+ os.path.join(self._chip_path, "export"), "w", encoding="utf-8"
+ ) as f_export:
f_export.write("{:d}\n".format(self._channel))
except IOError as e:
- raise PWMError(e.errno, "Exporting PWM channel: " + e.strerror)
+ raise PWMError(
+ e.errno, "Exporting PWM channel: " + e.strerror
+ ) from IOError
# Loop until PWM is exported
exported = False
with open(
os.path.join(self._channel_path, "period"),
"w",
+ encoding="utf-8",
):
break
except IOError as e:
self.frequency = frequency
self.duty_cycle = duty_cycle
+ self.polarity = "normal"
+ self.enable()
# Cache the period for fast duty cycle updates
self._period_ns = self._get_period_ns()
# Unexporting the PWM channel
try:
unexport_fd = os.open(
- os.path.join(self._chip_path, self._unexport), os.O_WRONLY
+ os.path.join(self._chip_path, "unexport"), os.O_WRONLY
)
os.write(unexport_fd, "{:d}\n".format(self._channel).encode())
os.close(unexport_fd)
except OSError as e:
- raise PWMError(e.errno, "Unexporting PWM: " + e.strerror)
+ raise PWMError(e.errno, "Unexporting PWM: " + e.strerror) from OSError
self._chip = None
self._channel = None
def _write_channel_attr(self, attr, value):
- with open(os.path.join(self._channel_path, attr), "w") as f_attr:
+ with open(
+ os.path.join(self._channel_path, attr), "w", encoding="utf-8"
+ ) as f_attr:
f_attr.write(value + "\n")
def _read_channel_attr(self, attr):
- with open(os.path.join(self._channel_path, attr), "r") as f_attr:
+ with open(
+ os.path.join(self._channel_path, attr), "r", encoding="utf-8"
+ ) as f_attr:
return f_attr.read().strip()
# Methods
def enable(self):
- """Enable the PWM outout."""
+ """Enable the PWM output."""
self.enabled = True
def disable(self):
- """Diable the PWM output."""
+ """Disable the PWM output."""
self.enabled = False
# Mutable properties
period = property(_get_period, _set_period)
"""Get or set the PWM's output period in seconds.
-
+
Raises:
PWMError: if an I/O or OS error occurs.
TypeError: if value type is not int.
-
+
:type: int, float
"""
period_ms = property(_get_period_ms, _set_period_ms)
"""Get or set the PWM's output period in milliseconds.
-
+
Raises:
PWMError: if an I/O or OS error occurs.
TypeError: if value type is not int.
-
+
:type: int, float
"""
period_us = property(_get_period_us, _set_period_us)
"""Get or set the PWM's output period in microseconds.
-
+
Raises:
PWMError: if an I/O or OS error occurs.
TypeError: if value type is not int.
-
+
:type: int
"""
def _get_period_ns(self):
- period_ns = self._read_channel_attr(self._pin_period)
+ period_ns = self._read_channel_attr("period")
try:
period_ns = int(period_ns)
except ValueError:
period_ns = property(_get_period_ns, _set_period_ns)
"""Get or set the PWM's output period in nanoseconds.
-
+
Raises:
PWMError: if an I/O or OS error occurs.
TypeError: if value type is not int.
-
+
:type: int
"""
except ValueError:
raise PWMError(
None, 'Unknown duty cycle value: "{:s}"'.format(duty_cycle_ns_str)
- )
+ ) from ValueError
return duty_cycle_ns
duty_cycle_ns = property(_get_duty_cycle_ns, _set_duty_cycle_ns)
"""Get or set the PWM's output duty cycle in nanoseconds.
-
+
Raises:
PWMError: if an I/O or OS error occurs.
TypeError: if value type is not int.
-
+
:type: int
"""
def _set_duty_cycle(self, duty_cycle):
if not isinstance(duty_cycle, (int, float)):
raise TypeError("Invalid duty cycle type, should be int or float.")
- elif not 0.0 <= duty_cycle <= 1.0:
+
+ if not 0.0 <= duty_cycle <= 1.0:
raise ValueError("Invalid duty cycle value, should be between 0.0 and 1.0.")
# Convert duty cycle from ratio to nanoseconds
def _set_polarity(self, polarity):
if not isinstance(polarity, str):
raise TypeError("Invalid polarity type, should be str.")
- elif polarity.lower() not in ["normal", "inversed"]:
+
+ if polarity.lower() not in ["normal", "inversed"]:
raise ValueError('Invalid polarity, can be: "normal" or "inversed".')
self._write_channel_attr("polarity", polarity.lower())
if enabled == "1":
return True
- elif enabled == "0":
+ if enabled == "0":
return False
raise PWMError(None, 'Unknown enabled value: "{:s}"'.format(enabled))
# String representation
def __str__(self):
- return "PWM {:d}, chip {:d} (period={:f} sec, duty_cycle={:f}%, polarity={:s}, enabled={:s})".format(
- self._channel,
- self._chip,
- self.period,
- self.duty_cycle * 100,
- self.polarity,
- str(self.enabled),
+ return (
+ "PWM {:d}, chip {:d} (period={:f} sec, duty_cycle={:f}%,"
+ " polarity={:s}, enabled={:s})".format(
+ self._channel,
+ self._chip,
+ self.period,
+ self.duty_cycle * 100,
+ self.polarity,
+ str(self.enabled),
+ )
)
projects / Adafruit_Blinka-hackapet.git / blobdiff