lib/libgpiod
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git synced 2026-10-25 12:39:18 +03:00
Code Activity

bindings: python: examples: replace tools examples with use case examples

Browse Source 
Replace tool examples with use case examples drawn from the tools.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
Signed-off-by: Bartosz Golaszewski <bartosz.golaszewski@linaro.org>
This commit is contained in:
Kent Gibson
2023-06-26 16:34:02 +08:00
committed by Bartosz Golaszewski
parent 46ecbe0f15
commit 96c52d3e59
20 changed files with 317 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
bindings/python/examples/Makefile.am
View File

@@ -3,13 +3,15 @@
EXTRA_DIST = \
async_watch_line_value.py \
find_line_by_name.py \
get_chip_info.py \
get_line_info.py \
get_line_value.py \
gpiodetect.py \
gpiofind.py \
gpioget.py \
gpioinfo.py \
gpiomon.py \
gpionotify.py \
gpioset.py \
get_multiple_line_values.py \
reconfigure_input_to_output.py \
toggle_line_value.py \
watch_line_value.py
toggle_multiple_line_values.py \
watch_line_requests.py \
watch_line_value.py \
watch_line_rising.py \
watch_multiple_line_values.py

9
bindings/python/examples/async_watch_line_value.py
View File

@@ -11,9 +11,9 @@ from datetime import timedelta
from gpiod.line import Bias, Edge
def edge_type(event):
def edge_type_str(event):
if event.event_type is event.Type.RISING_EDGE:
return "Rising "
return "Rising"
if event.event_type is event.Type.FALLING_EDGE:
return "Falling"
return "Unknown"
@@ -41,8 +41,9 @@ def async_watch_line_value(chip_path, line_offset):
poll.poll()
for event in request.read_edge_events():
print(
"offset: %d, type: %s, event #%d"
% (event.line_offset, edge_type(event), event.line_seqno)
"offset: {} type: {:<7} event #{}".format(
event.line_offset, edge_type_str(event), event.line_seqno
)
)

37
bindings/python/examples/find_line_by_name.py Executable file
View File

@@ -0,0 +1,37 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of finding a line with the given name."""
import gpiod
import os
def generate_gpio_chips():
for entry in os.scandir("/dev/"):
if gpiod.is_gpiochip_device(entry.path):
yield entry.path
def find_line_by_name(line_name):
# Names are not guaranteed unique, so this finds the first line with
# the given name.
for path in generate_gpio_chips():
with gpiod.Chip(path) as chip:
try:
offset = chip.line_offset_from_id(line_name)
print("{}: {} {}".format(line_name, chip.get_info().name, offset))
return
except OSError:
# An OSError is raised if the name is not found.
continue
print("line '{}' not found".format(line_name))
if __name__ == "__main__":
try:
find_line_by_name("GPIO19")
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

20
bindings/python/examples/get_chip_info.py Executable file
View File

@@ -0,0 +1,20 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of reading the info for a chip."""
import gpiod
def get_chip_info(chip_path):
with gpiod.Chip(chip_path) as chip:
info = chip.get_info()
print("{} [{}] ({} lines)".format(info.name, info.label, info.num_lines))
if __name__ == "__main__":
try:
get_chip_info("/dev/gpiochip0")
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

29
bindings/python/examples/get_line_info.py Executable file
View File

@@ -0,0 +1,29 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of reading the info for a line."""
import gpiod
def get_line_info(chip_path, line_offset):
with gpiod.Chip(chip_path) as chip:
info = chip.get_line_info(line_offset)
is_input = info.direction == gpiod.line.Direction.INPUT
print(
"line {:>3}: {:>12} {:>12} {:>8} {:>10}".format(
info.offset,
info.name or "unnamed",
info.consumer or "unused",
"input" if is_input else "output",
"active-low" if info.active_low else "active-high",
)
)
if __name__ == "__main__":
try:
get_line_info("/dev/gpiochip0", 3)
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

29
bindings/python/examples/get_multiple_line_values.py Executable file
View File

@@ -0,0 +1,29 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of reading multiple lines."""
import gpiod
from gpiod.line import Direction
def get_multiple_line_values(chip_path, line_offsets):
with gpiod.request_lines(
chip_path,
consumer="get-multiple-line-values",
config={tuple(line_offsets): gpiod.LineSettings(direction=Direction.INPUT)},
) as request:
vals = request.get_values()
for offset, val in zip(line_offsets, vals):
print("{}={} ".format(offset, val), end="")
print()
if __name__ == "__main__":
try:
get_multiple_line_values("/dev/gpiochip0", [5, 3, 7])
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

15
bindings/python/examples/gpiodetect.py
View File

@@ -1,15 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Reimplementation of the gpiodetect tool in Python."""
import gpiod
import os
from helpers import gpio_chips
if __name__ == "__main__":
for chip in gpio_chips():
info = chip.get_info()
print("{} [{}] ({} lines)".format(info.name, info.label, info.num_lines))

20
bindings/python/examples/gpiofind.py
View File

@@ -1,20 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Reimplementation of the gpiofind tool in Python."""
import gpiod
import os
import sys
if __name__ == "__main__":
for entry in os.scandir("/dev/"):
if gpiod.is_gpiochip_device(entry.path):
with gpiod.Chip(entry.path) as chip:
offset = chip.line_offset_from_id(sys.argv[1])
if offset is not None:
print("{} {}".format(chip.get_info().name, offset))
sys.exit(0)
sys.exit(1)

29
bindings/python/examples/gpioget.py
View File

@@ -1,29 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Simplified reimplementation of the gpioget tool in Python."""
import gpiod
import sys
from gpiod.line import Direction
if __name__ == "__main__":
if len(sys.argv) < 3:
raise TypeError("usage: gpioget.py <gpiochip> <offset1> <offset2> ...")
path = sys.argv[1]
lines = [int(line) if line.isdigit() else line for line in sys.argv[2:]]
request = gpiod.request_lines(
path,
consumer="gpioget.py",
config={tuple(lines): gpiod.LineSettings(direction=Direction.INPUT)},
)
vals = request.get_values()
for val in vals:
print("{} ".format(val.value), end="")
print()

28
bindings/python/examples/gpioinfo.py
View File

@@ -1,28 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Simplified reimplementation of the gpioinfo tool in Python."""
import gpiod
import os
from helpers import gpio_chips
if __name__ == "__main__":
for chip in gpio_chips():
cinfo = chip.get_info()
print("{} - {} lines:".format(cinfo.name, cinfo.num_lines))
for offset in range(0, cinfo.num_lines):
linfo = chip.get_line_info(offset)
is_input = linfo.direction == gpiod.line.Direction.INPUT
print(
"\tline {:>3}: {:>18} {:>12} {:>8} {:>10}".format(
linfo.offset,
linfo.name or "unnamed",
linfo.consumer or "unused",
"input" if is_input else "output",
"active-low" if linfo.active_low else "active-high",
)
)

26
bindings/python/examples/gpiomon.py
View File

@@ -1,26 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Simplified reimplementation of the gpiomon tool in Python."""
import gpiod
import sys
from gpiod.line import Edge
if __name__ == "__main__":
if len(sys.argv) < 3:
raise TypeError("usage: gpiomon.py <gpiochip> <offset1> <offset2> ...")
path = sys.argv[1]
lines = [int(line) if line.isdigit() else line for line in sys.argv[2:]]
with gpiod.request_lines(
path,
consumer="gpiomon.py",
config={tuple(lines): gpiod.LineSettings(edge_detection=Edge.BOTH)},
) as request:
while True:
for event in request.read_edge_events():
print(event)

21
bindings/python/examples/gpionotify.py
View File

@@ -1,21 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Bartosz Golaszewski <bartosz.golaszewski@linaro.org>
"""Simplified reimplementation of the gpionotify tool in Python."""
import gpiod
import sys
if __name__ == "__main__":
if len(sys.argv) < 3:
raise TypeError("usage: gpionotify.py <gpiochip> <offset1> <offset2> ...")
path = sys.argv[1]
with gpiod.Chip(path) as chip:
for line in sys.argv[2:]:
chip.watch_line_info(line)
while True:
print(chip.read_info_event())

36
bindings/python/examples/gpioset.py
View File

@@ -1,36 +0,0 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
"""Simplified reimplementation of the gpioset tool in Python."""
import gpiod
import sys
from gpiod.line import Direction, Value
if __name__ == "__main__":
if len(sys.argv) < 3:
raise TypeError(
"usage: gpioset.py <gpiochip> <offset1>=<value1> <offset2>=<value2> ..."
)
path = sys.argv[1]
def parse_value(arg):
x, y = arg.split("=")
return (x, Value(int(y)))
def make_settings(val):
return gpiod.LineSettings(direction=Direction.OUTPUT, output_value=val)
lvs = [parse_value(arg) for arg in sys.argv[2:]]
config = dict((l, make_settings(v)) for (l, v) in lvs)
request = gpiod.request_lines(
path,
consumer="gpioset.py",
config=config,
)
input()

15
bindings/python/examples/helpers.py
View File

@@ -1,15 +0,0 @@
# SPDX-License-Identifier: LGPL-2.1-or-later
# SPDX-FileCopyrightText: 2022 Bartosz Golaszewski <brgl@bgdev.pl>
import gpiod
import os
def gpio_chips():
for path in [
entry.path
for entry in os.scandir("/dev/")
if gpiod.is_gpiochip_device(entry.path)
]:
with gpiod.Chip(path) as chip:
yield chip

39
bindings/python/examples/reconfigure_input_to_output.py Executable file
View File

@@ -0,0 +1,39 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Example of a bi-directional line requested as input and then switched to output."""
import gpiod
from gpiod.line import Direction, Value
def reconfigure_input_to_output(chip_path, line_offset):
# request the line initially as an input
with gpiod.request_lines(
chip_path,
consumer="reconfigure-input-to-output",
config={line_offset: gpiod.LineSettings(direction=Direction.INPUT)},
) as request:
# read the current line value
value = request.get_value(line_offset)
print("{}={} (input)".format(line_offset, value))
# switch the line to an output and drive it low
request.reconfigure_lines(
config={
line_offset: gpiod.LineSettings(
direction=Direction.OUTPUT, output_value=Value.INACTIVE
)
}
)
# report the current driven value
value = request.get_value(line_offset)
print("{}={} (output)".format(line_offset, value))
if __name__ == "__main__":
try:
reconfigure_input_to_output("/dev/gpiochip0", 5)
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

47
bindings/python/examples/toggle_multiple_line_values.py Executable file
View File

@@ -0,0 +1,47 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of toggling multiple lines."""
import gpiod
import time
from gpiod.line import Direction, Value
def toggle_value(value):
if value == Value.INACTIVE:
return Value.ACTIVE
return Value.INACTIVE
def toggle_multiple_line_values(chip_path, line_values):
value_str = {Value.ACTIVE: "Active", Value.INACTIVE: "Inactive"}
request = gpiod.request_lines(
chip_path,
consumer="toggle-multiple-line-values",
config={
tuple(line_values.keys()): gpiod.LineSettings(direction=Direction.OUTPUT)
},
output_values=line_values,
)
while True:
print(
" ".join("{}={}".format(l, value_str[v]) for (l, v) in line_values.items())
)
time.sleep(1)
for l, v in line_values.items():
line_values[l] = toggle_value(v)
request.set_values(line_values)
if __name__ == "__main__":
try:
toggle_multiple_line_values(
"/dev/gpiochip0", {5: Value.ACTIVE, 3: Value.ACTIVE, 7: Value.INACTIVE}
)
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

23
bindings/python/examples/watch_line_info.py Executable file
View File

@@ -0,0 +1,23 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of watching for info changes on particular lines."""
import gpiod
def watch_line_info(chip_path, line_offsets):
with gpiod.Chip(chip_path) as chip:
for offset in line_offsets:
chip.watch_line_info(offset)
while True:
print(chip.read_info_event())
if __name__ == "__main__":
try:
watch_line_info("/dev/gpiochip0", [5, 3, 7])
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

32
bindings/python/examples/watch_line_rising.py Executable file
View File

@@ -0,0 +1,32 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of watching for rising edges on a single line."""
import gpiod
from gpiod.line import Edge
def watch_line_rising(chip_path, line_offset):
with gpiod.request_lines(
chip_path,
consumer="watch-line-rising",
config={line_offset: gpiod.LineSettings(edge_detection=Edge.RISING)},
) as request:
while True:
# Blocks until at least one event is available
for event in request.read_edge_events():
print(
"line: {} type: Rising event #{}".format(
event.line_offset, event.line_seqno
)
)
if __name__ == "__main__":
try:
watch_line_rising("/dev/gpiochip0", 5)
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")

7
bindings/python/examples/watch_line_value.py
View File

@@ -10,7 +10,7 @@ from datetime import timedelta
from gpiod.line import Bias, Edge
def edge_type(event):
def edge_type_str(event):
if event.event_type is event.Type.RISING_EDGE:
return "Rising"
if event.event_type is event.Type.FALLING_EDGE:
@@ -36,8 +36,9 @@ def watch_line_value(chip_path, line_offset):
# Blocks until at least one event is available
for event in request.read_edge_events():
print(
"line: %d type: %-7s event #%d"
% (event.line_offset, edge_type(event), event.line_seqno)
"line: {} type: {:<7} event #{}".format(
event.line_offset, edge_type_str(event), event.line_seqno
)
)

42
bindings/python/examples/watch_multiple_line_values.py Executable file
View File

@@ -0,0 +1,42 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: 2023 Kent Gibson <warthog618@gmail.com>
"""Minimal example of watching for edges on multiple lines."""
import gpiod
from gpiod.line import Edge
def edge_type_str(event):
if event.event_type is event.Type.RISING_EDGE:
return "Rising"
if event.event_type is event.Type.FALLING_EDGE:
return "Falling"
return "Unknown"
def watch_multiple_line_values(chip_path, line_offsets):
with gpiod.request_lines(
chip_path,
consumer="watch-multiple-line-values",
config={tuple(line_offsets): gpiod.LineSettings(edge_detection=Edge.BOTH)},
) as request:
while True:
for event in request.read_edge_events():
print(
"offset: {} type: {:<7} event #{} line event #{}".format(
event.line_offset,
edge_type_str(event),
event.global_seqno,
event.line_seqno,
)
)
if __name__ == "__main__":
try:
watch_multiple_line_values("/dev/gpiochip0", [5, 3, 7])
except OSError as ex:
print(ex, "\nCustomise the example configuration to suit your situation")