Using the GPIOs on your ZED Box Mini and Mini Carrier Board

1
import time
2
import gpiod
3
from gpiod.line import Direction, Value
4
5
# Get information about the GPIO chip
6
with gpiod.Chip("/dev/gpiochip0") as chip:
7
  info = chip.get_info()
8
  print(f"GPIO Chip: {info.name} [{info.label}] - {info.num_lines} lines")
9
10
# Define GPIO lines
11
line11 = 106 # GPIO_11
12
line12 = 85 # GPIO_12
13
14
# Set the lines as OUTPUT and set initial values to HIGH
15
request_out = gpiod.request_lines(
16
  "/dev/gpiochip0",
17
  consumer="example",
18
  config={
19
    line11: gpiod.LineSettings(direction=Direction.OUTPUT, output_value=Value.ACTIVE),
20
    line12: gpiod.LineSettings(direction=Direction.OUTPUT, output_value=Value.ACTIVE)
21
  }
22
)
23
24
# Toggle GPIO_11 and GPIO_12 values for 10 seconds
25
total=10
26
for i in range(total):
27
  if i%2 == 1:
28
    output11=Value.ACTIVE
29
    output12=Value.INACTIVE
30
  else:
31
    output11=Value.INACTIVE
32
    output12=Value.ACTIVE
33
  print(f"[{i+1}/{total} Set Value - GPIO_11: {output11} / GPIO_12: {output12}", end ='\r')
34
  # Set GPIO_11 LOW
35
  request_out.set_value(line11, output11)
36
  # Set GPIO_12 HIGH
37
  request_out.set_value(line12, output12)
38
  # Wait 1 second
39
  time.sleep(1)
40
41
print()
42
  
43
# Set both lines to LOW before releasing them
44
request_out.set_values(
45
  values={
46
    line11: Value.INACTIVE,
47
    line12: Value.INACTIVE
48
  }
49
)
50
51
# Release the lines
52
request_out.release()
53
 
54
# Set the lines as INPUT
55
request_in = gpiod.request_lines(
56
  "/dev/gpiochip0",
57
  consumer="example",
58
  config={
59
    line11: gpiod.LineSettings(direction=Direction.INPUT),
60
    line12: gpiod.LineSettings(direction=Direction.INPUT)
61
  }
62
)  
63
64
# Read GPIO_11 and GPIO_12 values for 10 seconds
65
duration=10.0
66
start = time.time()
67
exit = False
68
while (exit==False):
69
  now = time.time()
70
  elapsed = now-start
71
  if(elapsed>10):
72
    exit = True
73
   
74
  # Read GPIO11
75
  value11 = request_in.get_value(line11)
76
  # Read GPIO12
77
  value12 = request_in.get_value(line12)
78
  
79
  # Print the current values with remaining time
80
  remaining = int(duration-elapsed)  
81
  print(f"Read Value - GPIO_11: {value11} / GPIO_12: {value12} - to end: {remaining} sec", end ='\r')
82
print()

1
#include <iostream>
2
#include <string>
3
#include <gpiod.hpp>
4
#include <thread>
5
#include <chrono>
6
7
// Function to toggle single GPIO line value
8
gpiod::line::value toggle_value(::gpiod::line::value v);
9
10
// Function to toggle multiple GPIO line values
11
void toggle_values(gpiod::line::values &values);
12
13
// Function to print GPIO line offsets and their corresponding values
14
void print_values(gpiod::line::offsets const &offsets, gpiod::line::values const &values);
15
16
// Main function to demonstrate GPIO line manipulation
17
int main(void) {
18
19
    // Set the GPIO chip system path
20
    const std::filesystem::path chip_path("/dev/gpiochip0");
21
22
    // Define the GPIO line offsets to be used
23
    const ::gpiod::line::offsets line_offsets = { 
24
        106, // GPIO_11
25
        85   // GPIO_12
26
    };
27
    
28
    // Retrieve a GPIO chip by its path and print its name and label
29
    gpiod::chip chip(chip_path);
30
    auto info = chip.get_info();
31
32
    std::cout << "GPIO chip: " << info.name() << " [" << info.label() << "] ("
33
            << info.num_lines() << " lines)" << ::std::endl;
34
35
    // Initialize GPIO line values
36
    gpiod::line::values values = { 
37
        gpiod::line::value::ACTIVE,  // GPIO_11
38
        gpiod::line::value::INACTIVE // GPIO_12 
39
    };
40
41
    // Create a request to toggle multiple GPIO lines
42
    auto request =
43
        chip.prepare_request()
44
            .set_consumer("test_gpio")
45
            .add_line_settings(
46
                line_offsets,
47
                ::gpiod::line_settings().set_direction(
48
                    ::gpiod::line::direction::OUTPUT))
49
            .set_output_values(values)
50
            .do_request();
51
52
    // Toggle the GPIO lines for ten seconds
53
    const int duration = 10;
54
    for (int i = 0; i < duration; i++) {
55
        std::cout << "\r[" << (i + 1) << "/" << duration << "] Set Value: ";
56
        print_values(line_offsets, values);
57
        std::this_thread::sleep_for(std::chrono::seconds(1));
58
        toggle_values(values);
59
        request.set_values(line_offsets, values);
60
    }
61
62
    std::cout << std::endl;
63
64
    // Reconfigure the GPIO lines as inputs
65
    request.reconfigure_lines(gpiod::line_config().add_line_settings(
66
        line_offsets,
67
        gpiod::line_settings()
68
            .set_direction(::gpiod::line::direction::INPUT)));
69
70
    // Read and print the GPIO line values for ten seconds
71
    auto start = std::chrono::steady_clock::now();
72
    int64_t elapsed=0;
73
    do {
74
        // Read the current values of the GPIO lines
75
        auto read_values = request.get_values(line_offsets);
76
77
        // Print the read values
78
        std::cout << "\rRead Value: ";
79
        print_values(line_offsets, read_values);
80
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
81
82
        // Update elapsed time (sec)
83
        elapsed = (std::chrono::steady_clock::now() - start).count() / 1'000'000'000;
84
        std::cout << " - " << elapsed << " sec     " << std::flush;
85
    } while (elapsed < std::chrono::seconds(duration).count());
86
87
    std::cout << std::endl;
88
89
    return EXIT_SUCCESS;
90
}
91
92
gpiod::line::value toggle_value(::gpiod::line::value v)
93
{
94
    return (v == gpiod::line::value::ACTIVE) ?
95
               gpiod::line::value::INACTIVE :
96
               gpiod::line::value::ACTIVE;
97
}
98
99
void toggle_values(gpiod::line::values &values)
100
{
101
    for (size_t i = 0; i < values.size(); i++)
102
        values[i] = toggle_value(values[i]);
103
}
104
105
void print_values(gpiod::line::offsets const &offsets,
106
          gpiod::line::values const &values)
107
{    
108
    for (size_t i = 0; i < offsets.size(); i++)
109
        std::cout << (offsets[i]==106?"GPIO_11":"GPIO_12") << ": " << values[i] << " " << std::flush;
110
}