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

import time
import gpiod
from gpiod.line import Direction, Value
# Get information about the GPIO chip
with gpiod.Chip("/dev/gpiochip0") as chip:
  info = chip.get_info()
  print(f"GPIO Chip: {info.name} [{info.label}] - {info.num_lines} lines")
# Define GPIO lines
line11 = 106 # GPIO_11
line12 = 85 # GPIO_12
# Set the lines as OUTPUT and set initial values to HIGH
request_out = gpiod.request_lines(
  "/dev/gpiochip0",
  consumer="example",
  config={
    line11: gpiod.LineSettings(direction=Direction.OUTPUT, output_value=Value.ACTIVE),
    line12: gpiod.LineSettings(direction=Direction.OUTPUT, output_value=Value.ACTIVE)
  }
)
# Toggle GPIO_11 and GPIO_12 values for 10 seconds
total=10
for i in range(total):
  if i%2 == 1:
    output11=Value.ACTIVE
    output12=Value.INACTIVE
  else:
    output11=Value.INACTIVE
    output12=Value.ACTIVE
  print(f"[{i+1}/{total} Set Value - GPIO_11: {output11} / GPIO_12: {output12}", end ='\r')
  # Set GPIO_11 value
  request_out.set_value(line11, output11)
  # Set GPIO_12 value
  request_out.set_value(line12, output12)
  # Wait 1 second
  time.sleep(1)
print()
  
# Set both lines to LOW before releasing them
request_out.set_values(
  values={
    line11: Value.INACTIVE,
    line12: Value.INACTIVE
  }
)
# Release the lines
request_out.release()
 
# Set the lines as INPUT
request_in = gpiod.request_lines(
  "/dev/gpiochip0",
  consumer="example",
  config={
    line11: gpiod.LineSettings(direction=Direction.INPUT),
    line12: gpiod.LineSettings(direction=Direction.INPUT)
  }
)  
# Read GPIO_11 and GPIO_12 values for 10 seconds
duration=10.0
start = time.time()
exit = False
while (exit==False):
  now = time.time()
  elapsed = now-start
  if(elapsed>10):
    exit = True
   
  # Read GPIO11
  value11 = request_in.get_value(line11)
  # Read GPIO12
  value12 = request_in.get_value(line12)
  
  # Print the current values with remaining time
  remaining = int(duration-elapsed)  
  print(f"Read Value - GPIO_11: {value11} / GPIO_12: {value12} - to end: {remaining} sec", end ='\r')
print()

#include <iostream>
#include <string>
#include <gpiod.hpp>
#include <thread>
#include <chrono>
// Function to toggle single GPIO line value
gpiod::line::value toggle_value(::gpiod::line::value v);
// Function to toggle multiple GPIO line values
void toggle_values(gpiod::line::values &values);
// Function to print GPIO line offsets and their corresponding values
void print_values(gpiod::line::offsets const &offsets, gpiod::line::values const &values);
// Main function to demonstrate GPIO line manipulation
int main(void) {
    // Set the GPIO chip system path
    const std::filesystem::path chip_path("/dev/gpiochip0");
    // Define the GPIO line offsets to be used
    const ::gpiod::line::offsets line_offsets = { 
        106, // GPIO_11
        85   // GPIO_12
    };
    
    // Retrieve a GPIO chip by its path and print its name and label
    gpiod::chip chip(chip_path);
    auto info = chip.get_info();
    std::cout << "GPIO chip: " << info.name() << " [" << info.label() << "] ("
            << info.num_lines() << " lines)" << ::std::endl;
    // Initialize GPIO line values
    gpiod::line::values values = { 
        gpiod::line::value::ACTIVE,  // GPIO_11
        gpiod::line::value::INACTIVE // GPIO_12 
    };
    // Create a request to toggle multiple GPIO lines
    auto request =
        chip.prepare_request()
            .set_consumer("test_gpio")
            .add_line_settings(
                line_offsets,
                ::gpiod::line_settings().set_direction(
                    ::gpiod::line::direction::OUTPUT))
            .set_output_values(values)
            .do_request();
    // Toggle the GPIO lines for ten seconds
    const int duration = 10;
    for (int i = 0; i < duration; i++) {
        std::cout << "\r[" << (i + 1) << "/" << duration << "] Set Value: ";
        print_values(line_offsets, values);
        std::this_thread::sleep_for(std::chrono::seconds(1));
        toggle_values(values);
        request.set_values(line_offsets, values);
    }
    std::cout << std::endl;
    // Reconfigure the GPIO lines as inputs
    request.reconfigure_lines(gpiod::line_config().add_line_settings(
        line_offsets,
        gpiod::line_settings()
            .set_direction(::gpiod::line::direction::INPUT)));
    // Read and print the GPIO line values for ten seconds
    auto start = std::chrono::steady_clock::now();
    int64_t elapsed=0;
    do {
        // Read the current values of the GPIO lines
        auto read_values = request.get_values(line_offsets);
        // Print the read values
        std::cout << "\rRead Value: ";
        print_values(line_offsets, read_values);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        // Update elapsed time (sec)
        elapsed = (std::chrono::steady_clock::now() - start).count() / 1'000'000'000;
        std::cout << " - " << elapsed << " sec     " << std::flush;
    } while (elapsed < std::chrono::seconds(duration).count());
    std::cout << std::endl;
    return EXIT_SUCCESS;
}
gpiod::line::value toggle_value(::gpiod::line::value v)
{
    return (v == gpiod::line::value::ACTIVE) ?
               gpiod::line::value::INACTIVE :
               gpiod::line::value::ACTIVE;
}
void toggle_values(gpiod::line::values &values)
{
    for (size_t i = 0; i < values.size(); i++)
        values[i] = toggle_value(values[i]);
}
void print_values(gpiod::line::offsets const &offsets,
          gpiod::line::values const &values)
{    
    for (size_t i = 0; i < offsets.size(); i++)
        std::cout << (offsets[i]==106?"GPIO_11":"GPIO_12") << ": " << values[i] << " " << std::flush;
}