Rpi.gpio 0.7.0

ACPI¶

ACPI also supports function names for GPIOs in a similar fashion to DT.
The above DT example can be converted to an equivalent ACPI description
with the help of _DSD (Device Specific Data), introduced in ACPI 5.1:

Device (FOO) {
        Name (_CRS, ResourceTemplate () {
                GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
                        "\\_SB.GPI0") {15} // red
                GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
                        "\\_SB.GPI0") {16} // green
                GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
                        "\\_SB.GPI0") {17} // blue
                GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
                        "\\_SB.GPI0") {1} // power
        })

        Name (_DSD, Package () {
                ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
                Package () {
                        Package () {
                                "led-gpios",
                                Package () {
                                        ^FOO, 0, 0, 1,
                                        ^FOO, 1, 0, 1,
                                        ^FOO, 2, 0, 1,
                                }
                        },
                        Package () {
                                "power-gpios",
                                Package () {^FOO, 3, 0, 0},
                        },
                }
        })
}

Как устроено GPIO на RPi3?

Теперь можно перейти к вопросу, который касается того, какая распиновка GPIO имеется на Raspberry Pi 3. В первую очередь необходимо сказать, что общее количество пинов на соответствующей панели равняется 40. Каждый из них имеет свой номер.

Все они подразделяются на 3 группы. К первой относятся питающие (на англоязычных схемах маркируются как Power) – они подают электричество в 3,3 и 5 Вольт. При этом у разных контактов данного назначения различное напряжение. Это обязательно следует учитывать при подключении модулей.

Ко второй – заземляющие (могут именоваться RND или Ground). Они нужны, чтобы отводить электричество, тем самым обеспечивая безопасное использование.

К третьей – порты (имеют обозначение BCM). Именно они служат теми контактами, которые могут принимать и отправлять сигналы. Пользователь может подключать модули к любым из них. Самое главное – чтобы было удобно обеспечивать питание подсоединённых компонентов.

Разобравшись с тем, какие типы контактов присутствуют в GPIO, можно перейти непосредственно к тому, какие из них конкретно за что отвечают. Самый простой способ освоить распиновку – это изучить схему. Но если такой возможности нет, можно обойтись и описанием.

Предположим, что плата расположена горизонтально таким образом, что GPIO на ней находится в левом верхнем углу. В таком случае номера портов будут располагаться так:

левый нижний – 1;
левый верхний – 2;
нижний во втором ряду – 3;
верхний во втором ряду – 4 и т.д.

Из списка выше должно быть понятно, по какому принципу выполнена нумерация соответствующего интерфейса. Теперь можно перейти к тому, контакты под какими номерами имеют какое назначение.

Питающие на 3,3 Вольта – 1 и 17, а на 5 Вольт – 2 и 4 (они находятся рядом). Заземляющие внизу – 9, 25 и 39, заземляющие вверху – 6, 14, 20, 30 и 34. Все остальные контакты – это порты (BCM).

Особенности нумерации GPIO

Чтобы начать использование GPIO в Raspberry Pi 3, необходимо знать какие существуют особенности нумерации контактов у данного интерфейса

Важно понимать, что в процессоре «Малины» не записаны номера пинов, которые не работают на вход/выход, то есть не являются портами

Поэтому при управлении GPIO на Raspberry Pi 3 необходимо знать нумерацию BCM. Она в значительной степени отличается от той, которая рассмотрена в разделе выше. Так, 3 контакт (он является портом) имеет номер BCM2. Именно такой следует указывать при написании кода.

Понятно, что из-за этого может возникнуть путаница. Ввиду этого на Raspberry Pi 3 рекомендуется использовать Wiring Pi. Это специальная библиотека, которая имеет собственную нумерацию. Так, например, 3 порт (который является BCM 2) определяется как WiringPi 8. Возможно, это покажется еще более нелогичным. Но после ознакомления с соответствующей схемой все встанет на свои места.

Что нужно знать о GPIO RPI3?

Модули возможно подключать к абсолютно любым портам GPIO «Малины», и они будут нормально работать

Но важно знать, что в системе есть пара контактов, которые зарезервированы системой для особых целей. Ими являются BCM 0 и BCM 1 (их номера на обычной схеме – 27 и 28)

Они предназначаются специально для установки плат расширения. Поэтому при возможности их не нужно использовать для подключения других модулей.

Еще один важный момент – осторожное использование питания через GPIO Raspberry Pi 3. Ток на внешние устройства через «Малину» может подаваться с силой до 50 мА

Это достаточно много для столь небольшого девайса. Поэтому подавать ток под такой силой нужно только по крайней необходимости. В противном случае можно не только испортить модуль, но и процессор самой RPi.

Interrupts with RPi.GPIO wait_for_edge()

#!/usr/bin/env python3

import RPi.GPIO as GPIO

BUTTON_GPIO = 16

if __name__ == '__main__':
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)

    while True:
        GPIO.wait_for_edge(BUTTON_GPIO, GPIO.FALLING)
        print("Button pressed!")

Use the function to wait (block) until a GPIO’s state changes. This function takes 2 (+1 optional) arguments:

channel: here the GPIO number (BCM mode).
type of interrupt.
(optional) timeout.

Here for the type of interrupt we used GPIO.FALLING as the button’s state is HIGH by default, due to the internal pull up resistor.

If you want to wait until the button is released, use GPIO.RISING instead.

And there is a third option: if you want to wait until either the button is pressed or released (both RISING and FALLING), use BOTH. In this case you’ll have to read the button’s state to know if the signal is LOW or HIGH.

For example:

    while True:
        GPIO.wait_for_edge(BUTTON_GPIO, GPIO.BOTH)
        if not GPIO.input(BUTTON_GPIO):
            print("Button pressed!")
        else:
            print("Button released!")

Note: for now we haven’t used any debounce mechanism, so you can sometimes get a weird behavior. A button is a physical system that will bounce when you press or release it, so it may seem like you pressed the button multiple times whereas you only did it once.

Interrupts with add_event_detect() and threaded callback

Using is nice, but it completely blocks the main thread. You’d have to spawn multiple threads yourself if you want to use this function along with other running code.

There is another function in the RPi.GPIO module which is more practical to use: , along with a callback function. This is the solution you’ll use most of the time.

Let’s see how this works.

Python code with RPi.GPIO

#!/usr/bin/env python3

import signal
import sys
import RPi.GPIO as GPIO

BUTTON_GPIO = 16

def signal_handler(sig, frame):
    GPIO.cleanup()
    sys.exit(0)

def button_pressed_callback(channel):
    print("Button pressed!")

if __name__ == '__main__':
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)

    GPIO.add_event_detect(BUTTON_GPIO, GPIO.FALLING, 
            callback=button_pressed_callback, bouncetime=100)
    
    signal.signal(signal.SIGINT, signal_handler)
    signal.pause()

Let’s break down this code step by step.

Code explained

#!/usr/bin/env python3

import signal
import sys
import RPi.GPIO as GPIO

BUTTON_GPIO = 16

First we add the necessary imports. We’ll use the signal module to be able to handle CTRL+C and make the program pause indefinitely.

def signal_handler(sig, frame):
    GPIO.cleanup()
    sys.exit(0)

This callback will be triggered when the user presses CTRL+C (we’ll setup that below in the main function). That’s an opportunity to do some cleanup before actually exiting the program.

def button_pressed_callback(channel):
    print("Button pressed!")

This is the callback for the function. When an interrupt with the chosen pin is triggered, this callback will be called. In the callback you get the channel – or GPIO number – as a parameter.

if __name__ == '__main__':
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)

Nothing new here, we initialize the button GPIO the same way we did before, with the internal pull up resistor activated.

    GPIO.add_event_detect(BUTTON_GPIO, GPIO.FALLING, 
            callback=button_pressed_callback, bouncetime=100)

After you’ve initialized the GPIO mode to input, this is where you can use the function to register a callback for an interrupt on this GPIO. The function takes a maximum of 4 parameters:

channel: GPIO number (here because BCM mode).
type of interrupt: GPIO.FALLING, GPIO.RISING, or GPIO.BOTH.
(optional) callback: function to be called when an interrupt is triggered. This is optional because you can choose to register a callback with another function – (but there’s no point here), or you can just not use a callback at all and see if an interrupt has been triggered with (but you’re going back to polling mode in this case).
(optional) bouncetime, in milliseconds. In case multiple interrupts are triggered in a short amount of time – due to button bounce – the callback will only be called once.

So, with the parameters we gave to it, the function will trigger as soon as the signal from the button’s GPIO is falling (HIGH to LOW), with a debounce time of 100 milliseconds.

    signal.signal(signal.SIGINT, signal_handler)
    signal.pause()

And finally, here we register the callback for CTRL+C handling, and make the program pause indefinitely with (because if we don’t do that, the main function will exit right away).

Improvement: detect both rising and falling signals

Here’s the code if you want to detect both changes in signal.

#!/usr/bin/env python3          
                                
import signal                   
import sys
import RPi.GPIO as GPIO

BUTTON_GPIO = 16

def signal_handler(sig, frame):
    GPIO.cleanup()
    sys.exit(0)

def button_callback(channel):
    if not GPIO.input(BUTTON_GPIO):
        print("Button pressed!")
    else:
        print("Button released!")

if __name__ == '__main__':
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    
    GPIO.add_event_detect(BUTTON_GPIO, GPIO.BOTH, 
            callback=button_callback, bouncetime=50)
    
    signal.signal(signal.SIGINT, signal_handler)
    signal.pause()

In the callback function you’ll have to check what’s the current GPIO’s state (LOW or HIGH) because at this point you don’t know if you come from a rising or falling interrupt. You only know it’s one of them.

Another change here: I’ve set the bouncetime to 50 milliseconds instead of 100 milliseconds. This will avoid missing some triggers when you press + release the button fast. Setting the bouncetime can be quite tricky: you don’t want to put too much so you don’t miss triggers, but you don’t want to put too little either so you don’t get undesired triggers. You’ll have to do some tests in your programs – and also, you can change the hardware to get a better quality button with much less bounce.

Arrays of pins¶

In addition to requesting pins belonging to a function one by one, a device may
also request an array of pins assigned to the function. The way those pins are
mapped to the device determines if the array qualifies for fast bitmap
processing. If yes, a bitmap is passed over get/set array functions directly
between a caller and a respective .get/set_multiple() callback of a GPIO chip.

In order to qualify for fast bitmap processing, the array must meet the
following requirements:

pin hardware number of array member 0 must also be 0,
pin hardware numbers of consecutive array members which belong to the same
chip as member 0 does must also match their array indexes.

Otherwise fast bitmap processing path is not used in order to avoid consecutive
pins which belong to the same chip but are not in hardware order being processed
separately.

If the array applies for fast bitmap processing path, pins which belong to
different chips than member 0 does, as well as those with indexes different from
their hardware pin numbers, are excluded from the fast path, both input and
output. Moreover, open drain and open source pins are excluded from fast bitmap
output processing.

Hello GPIO

Vediamo ora un piccolo esempino che ci aiuterà a capire le basi per controllare qualche pin.
Questo qua sotto è il circuito che andremo ad attaccare al nostro Raspberry

Abbiamo quindi bisogno di due led, due resistenze da 330Ω e un pulsante.
Il cavo blu andrà collegato al pin numero 11 che è il GPIO17, il cavo rosso al numero 15 che è il GPIO22 e il cavo arancione al numero 36 che è il GPIO16.
Il circuito farà una cosa molto semplice: di default sarà acceso il led di sinistra ma, tendendo premuto il pulsante, spegniamo quello di sinistra e accendiamo quello di destra. Quindi dovremo mantenere alto il GPIO17 in uscita e quando leggeremo sul GPIO16 «premuto», abbassiamo GPIO17 e alziamo GPIO22.. easy!

Per programmare useremo python perché tutto è pronto out-of-the-box nel senso che le librerie che ci permettono di mandare e ricevere segnali tramite interfaccia GPIO, sono già installate.
Se avete già familiarità con Arduino, tutto vi saprà di già visto

hello-gpio.py

Python

#importiamo le librerie per il controllo dell’interfaccia GPIO
import RPi.GPIO as GPIO

#definiamo il sistema di riferimento dei pin. Con GPIO.BCM usiamo i numeri GPIO dei pin e non il numero dei pin.
#Ad esempio con GPIO.BCM per riferirci al pin GPIO17, usiamo 17 (e non 11). Per indicare che
#ci si riferisce al numero del pin, si usa GPIO.setmode(GPIO.BOARD)
GPIO.setmode(GPIO.BCM)

#definiamo il numero GPIO dei pin in gioco
pinButton = 16
pinLedLeft = 17
pinLedRight = 22

#definiamo che pinLedLeft e pinLedRight sono due pin di output
GPIO.setup(pinLedLeft , GPIO.OUT)
GPIO.setup(pinLedRight , GPIO.OUT)

#definiamo che pinButton è un pin di input con un valore di default a 1
GPIO.setup(pinButton, GPIO.IN, pull_up_down=GPIO.PUD_UP)

#inizializziamo il led di destra spento
GPIO.output(pinLedRight, GPIO.LOW)

while 1:
#quando il pulsante è premuto…
if GPIO.input(pinButton):
#…accendi il led di destra e spegni quello di sinistra
GPIO.output(pinLedRight, GPIO.HIGH)
GPIO.output(pinLedLeft , GPIO.LOW)
else:
#…altrimenti torna nella configurazione iniziale
GPIO.output(pinLedRight, GPIO.LOW)
GPIO.output(pinLedLeft , GPIO.HIGH)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#importiamo le librerie per il controllo dell’interfaccia GPIO

importRPi.GPIO asGPIO

GPIO.setmode(GPIO.BCM)

#definiamo il numero GPIO dei pin in gioco

pinButton=16

pinLedLeft=17

pinLedRight=22

#definiamo che pinLedLeft e pinLedRight sono due pin di output

GPIO.setup(pinLedLeft,GPIO.OUT)

GPIO.setup(pinLedRight,GPIO.OUT)

#definiamo che pinButton è un pin di input con un valore di default a 1

GPIO.setup(pinButton,GPIO.IN,pull_up_down=GPIO.PUD_UP)

#inizializziamo il led di destra spento

GPIO.output(pinLedRight,GPIO.LOW)

while1

#quando il pulsante è premuto…

ifGPIO.input(pinButton)

#…accendi il led di destra e spegni quello di sinistra

GPIO.output(pinLedRight,GPIO.HIGH)

GPIO.output(pinLedLeft,GPIO.LOW)

else

#…altrimenti torna nella configurazione iniziale

GPIO.output(pinLedRight,GPIO.LOW)

GPIO.output(pinLedLeft,GPIO.HIGH)

Come vedete anche voi è molto intuitivo. Per esercizio provate a modificare il codice in modo che una volta cliccato il pulsante si lascia acceso il led che prima era spento e spegnere quello che prima era acceso.

Per ora è tutto. Se avete delle domande, non esitate a lasciarci un commento.
A breve nuovi articoli a riguardo, a presto!

Andrea Salvi

Basic Steps

If your system has a suitable sysfs driver loaded, you will see the GPIO hardware exposed in the file system under /sys/class/gpio. On a Raspberry Pi it might look something like this:

$ ls /sys/class/gpio/
export* gpiochip0@ gpiochip100@ gpiochip504@ unexport*

We’ll look at how to use this interface next. Note that the device names starting with «gpiochip» are the GPIO controllers and we won’t directly use them.

The basic steps to use a GPIO pin from the sysfs interface are the following:

Export the pin.
Set the pin direction (input or output).
If an output pin, set the level to low or high.
If an input pin, read the pin’s level (low or high).
When done, unexport the pin.

To export a pin, we write the pin name/number to the pseudo file /sys/class/gpio/export. This indicates that we want to use a specific GPIO pin and makes it visible in the sysfs file system hierarchy. Later when we are done, we can unexport the pin. Needing to explicitly export a pin can help prevent errors where one might inadvertently attempt to access the wrong pin.

As an example, we can export GPIO pin 24 (which corresponds to physical pin number 18 on the GPIO connector of the Raspberry Pi) with this shell command:

$ echo 24 >/sys/class/gpio/export

We will now see a gpio24 device appear under /sys/class gpio that was not there before:

$ ls /sys/class/gpio
export* gpio24@ gpiochip0@ gpiochip100@ gpiochip504@ unexport*

This is a symbolic link to a directory which has a number of files in it:

$ ls /sys/class/gpio/gpio24/
active_low* device@ direction* edge* power/ subsystem@ uevent* value*

Step 2 is to set the pin to be either an input or an output. This is done by writing either «in», or «out» to the direction file we saw above. For example, to set gpio24 as an input we would do:

$ echo in >/sys/class/gpio/gpio24/direction

Or to set it as an output:

$ echo out >/sys/class/gpio/gpio24/direction

The file can be read back if you want to check the current status:

$ cat /sys/class/gpio/gpio24/direction
out

While this may not be true for all hardware, a GPIO pin will generally default to being an input as this is always safe to do at the hardware level.

If we are configuring an output pin, we can now set it’s level. You write the value 0 or 1 (corresponding to low or high) to the value file for the pin. Continuing our example this could be done with:

$ echo 0 >/sys/class/gpio/gpio24/value

to set it low, or

$ echo 1 >/sys/class/gpio/gpio24/value

to set it high.

If we had configured the pin as an input and tried to do this, we would get an error because it is not valid to set the value of an input pin:

bash: echo: write error: Operation not permitted

If it had been configured as an input pin, we can read its value using the same file:

$ cat /sys/class/gpio/gpio24/value
0

In this case 0 or low.

You may be wondering if it is valid to read the value of an output pin, and the answer is yes. The value you read back depends on the actual hardware. On the Raspberry Pi you should see the same value that was output, but on some hardware it may reflect the actual signal level, which may be different if external hardware is driving it high or low.

The final step, if you are finished using the GPIO pin, is to unexport it. To do this, just write the pin name to the unexport file, i.e.

$ echo 24 >/sys/class/gpio/unexport

After doing this, the entry for gpio24 will no longer appear in sysfs:

$ ls /sys/class/gpio
export* gpiochip0@ gpiochip100@ gpiochip504@ unexport*

Parts of the Raspberry Pi 3 B+ Model

Parts of Raspberry Pi 3 B+

Processor: The BCM2837B0 processor is the main component of this tiny board that helps in carrying out a large set of instructions based on mathematical and logical formulas. BCM2837B0 is a 1.4GHz 64bit ARM quad-core Cortex A53 processor.

RAM: RAM used in R-Pi 3 B+ is 1GB LPDDR2 SDRAM (similar to the previous version)

GPU: It stands for graphics processing unit and is used for performing out the image calculation. The GPU uses OpenGL ES version 2.0, hardware-accelerated OpenVG API, and 1080p30 H.264 high-profile decode. It can provide up to 1Gpixel/s, 1.5Gtexel/s, or 24 GFLOPs of a general-purpose computer.

USB Ports: Similar to model B, model B+ also consists of 4 USB ports. Thus removing the hassle of connecting the USB hub in order to increase the ports.

Micro USB Power Source Connector: This connector is used for delivering 5V power to the board. It consumes approx. 170 to 200mA more power than model B. The power connector is also repositioned in the new B+ model and placed next to the HDMI socket.

HDMI and Composite Connection: Both the audio output socket and the video composite socket reside in a single 4-pole 3.5mm socket which is placed near the HDMI port, and now all the power and audio-video composite socket are placed on the one side of the board which gives it a clean and nice look.

USB Hard Drive: The board is capable of using an external USB hard drive.

PoE: B+ model comes with a facility of Power over Ethernet (PoE); a new feature added in this device which allows us to power the board using the ethernet cables.

Other Changes: The B+ version also comes with other improvements like the SD memory slot is replaced by a micro SD memory card slot (works similar to the previous version). The status LEDs on the board now only contain red and green colors and are relocated to the opposite end of the board.

Через что возможно взаимодействовать с GPIO Raspberry

Работать с GPIO Raspberry Pi можно практически через любой инструмент. К сегодняшнему дню созданы соответствующие библиотеки почти под все распространенные языки программирования. С GPIO Raspberry Pi возможно взаимодействовать даже через PHP и JavaScript (node.js).

Однако человеку, который только начинает знакомиться с «Малиной», рекомендуется пробовать взаимодействовать с данным интерфейсом посредством Python. Это обусловлено, во-первых, что для GPIO в Raspbian уже предустановлена соответствующая библиотека для Пайтона, а, во-вторых, этот ЯП является основным для рассматриваемого одноплатника.

Однако при желании, конечно, возможно пользоваться и любыми другими инструментами. Найти название библиотек и описание их не составляет никакого труда.

Обзор плат Raspberry Pi

Raspberry Pi – это миниатюрный одноплатный компьютер, который с лёгкостью поместится на ладони взрослого человека. Несмотря на свои скромные размеры, плата имеет высокую производительность, что позволяет ей выйти на один уровень со стационарными ПК. Изначально Raspberry Pi была разработана, как учебное пособие по информатике. Но сама идея оказалась настолько удачной, что за несколько лет мини-компьютер стал популярен в очень широких кругах. С течением времени Raspberry Pi пережила несколько модификаций, каждая из которых отличалась от предшественника каким-либо параметром. Такой подход позволил регулировать стоимость изделия в зависимости от потребностей пользователя, что также положительно сказалось на популярности устройства. Вся линейка Raspberry Pi применяет процессоры с АРМ-архитектурой, которая зарекомендовала себя с лучшей стороны. На рисунке №1 показан внешний вид одной из популярных плат Raspberry Pi В+.

Рисунок №1 – обзор составных элементов Raspberry Pi

На сегодняшний день (период 2012-2019гг.) существует 11 разновидностей Raspberry Pi. Последние версии оснащены беспроводными WiFi и Bluetooth модулями, расширяющими границы применения мини-пк в области Ethernet-технологий. Ниже приведена сравнительная таблица, в которой отражены особенности каждой модификации с указанием некоторых технических данных.

Модификация	Процессор	Тактовая частота	Количество ядер	Объём ОЗУ	Количество GPIO	Количество USB	Поддержка Ethernet	Поддержка WiFi	Поддержка Bluetooth	Год выпуска
В	ARM1176JZ-F	700 МГц	1	512 МБ	26	2	√			2012
А	ARM1176JZ-F	700 МГц	1	256 МБ	26	1				2013
В+	ARM1176JZ-F	700 МГц	1	512 МБ	40	4	√			2014
А+	ARM1176JZ-F	700 МГц	1	256 МБ	40	1				2014
2В	ARM Cortex-A7	900 МГц	4	1 ГБ	40	4	√			2015
Zero	ARM1176JZ-F	1 ГГц	1	512 МБ	40	1				2015
3B	Cortex-A53 (ARM v8)	1,2 ГГц	4	1 ГБ	40	4	√	802.11n	4.1	2016
Zero W	ARM1176JZ-F	1 ГГц	1	512 МБ	40	1		802.11n	4.0	2017
3B+	Cortex-A53 (ARM v8)	1,4 ГГц	4	1 ГБ	40	4	√	802.11n	4.2	2018
3A+	Cortex-A53 (ARM v8)	1,4 ГГц	4	512 МБ	40	1		802.11n	4.2	2018
4B	Cortex-A72 (ARM v8)	1,5 ГГц	4	1, 2, 4 ГБ	40	4	√	802.11n	5.0	2019

Как видно из вышеприведенной таблицы, даже самая младшая модель в линейке имеет вполне серьёзные характеристики, учитывая то, что это одноплатный компьютер размером чуть больше кредитной карты.

На рисунке №2 изображена последняя на момент написания статьи модификация Raspberry Pi 4В, запущенная в продажу в июне 2019г. Она оснащена дополнительным графическим процессором VideoCore VI (OpenGL ES 3.x), а также аппаратным декодером 4Kp60 для воспроизведения HEVC видео. Два порта microHDMI с возможностью пропускать сигнал до 4К, позволяют подключить одновременно два монитора.

Рисунок №2 – внешний вид Raspberry Pi 4В

Основной отличительной чертой Raspberry Pi от обычных компьютеров, является наличие программируемых портов ввода-вывода GPIO. С помощью них можно управлять различными устройствами и принимать телеметрию с различного рода датчиков.

License

(The MIT License)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the «Software»), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED «AS IS», WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Что такое GPIO и для чего он нужен?

Новичкам будет полезно узнать о том, что собой представляет GPIO. Это интерфейс, который предназначен для обеспечения связи между компонентами компьютера. В случае с «Малиной» он необходим для работы основной системы с дополнительными компонентами, которые называются модулями.

Пины в GPIO могут выполнять 3 функции:

подача электричества определенного напряжения;
заземление;
прием/отправка сигналов.

Интересно то, что за вход и выход в интерфейсе могут отвечать одни и те же контакты. По крайней мере это справедливо для RPi. То, как они себя должны вести, определяется программой.

Features

This library enables developers to use the various Raspberry Pi’s hardware modules:

Provides access to the official Raspberry Pi Camera module.
Provides information on this Raspberry Pi’s CPU and form factor.
Provides access to the Raspberry Pi’s GPIO as a collection of GPIO Pins.
Provides access to the 2-channel SPI bus.
Provides access to the functionality of the I2C bus.
Provides access to The PI’s Timing and threading API.

Peripherals

We offer an additional package with helpful classes to use peripherals, many of them are from pull requests from our contributors. The current set of peripherals supported are:

Infrared Sensor HX-1838
Led Strip APA-102C
NFC/RFID Controller MFRC-522
DHT family digital relative humidity and temperature sensors:
- DHT11
- DHT12
- DHT21 / AM-2301
- DHT22 / AM-2302
OLED Display SSD-1306
Generic Button connected to GPIO
GY-521 MPU6050 Accelerometer
Ultrasonic Sensor HC-SR04
ADS1015 and ADS1115 I2C Analog-to-Digital Converter devices

Распиновка DSI разъема дисплея

Display Serial Interface (DSI) — спецификация Mobile Industry Processor Interface (MIPI) Alliance. направленная на снижение затрат на дисплейную подсистему в мобильных устройствах. В основном она ориентирована на LCD и тому подобные технологии дисплея. Спецификация определяет последовательную шину и протокол связи между хостом (источник изображения) и устройством (получателем изображения).

Pin	Назначение
1	DISP_GND
2	DISP_D1_N
3	DISP_D1_P
4	DISP_GND
5	DISP_CK_N
6	DISP_CK_P
7	DISP_GND
8	DISP_D0_N
9	DISP_D0_P
10	DISP_GND
11	DISP_SCL
12	DISP_SDA
13	DISP_GND
14	DISP_3V3
15	DISP_3V3

UART — Universal Asynchronous Receiver / Transmitter

Commonly known as “Serial,” the UART pins (Transmit GPIO14, Receive GPIO15) provide a console / terminal login for headless setup, which means connecting to the Pi without a keyboard or pointing device. Normally, the easiest way to do a headless Raspberry Pi setup is simply to control the Pi over a network or direct USB connection (in the case of Pi Zero).

But, if there’s no network connection, you can also control a headless Pi using a serial cable or USB to serial board from a computer running a terminal console. UART is exceptionally reliable and provides access to a Pi without the need for extra equipment. Just remember to enable the Serial Console in the Raspberry Pi Configuration application. Chances are that you won’t want to do this, but the UART support is there if you need it.

Критика uapi

Официальной или неофициальной критики нет, или я её не нашёл. Поэтому обойдемся парой собственных мыслей.

Непонятно почему обошли стороной push-pull, debounce, и pull-up, pull-down.
В struct gpioevent_data неплохо было бы добавить параметр value с текущим значением линии

Критика sysfs gpio

Невозможно включить выключить сразу несколько линий одним вызовом
Для работы sysfs должен быть включен соответствующий ключ в конфигурации ядра
В случае краха приложения gpio линии остаются в «инициализированном» состоянии
Затруднён поиск необходимой линии
«Sysfs is horribly broken»

В общем, и, если честно, я считаю, что sysfs вполне нормален, для тех задач, которые возлагаются на gpio в userspace. В нём есть нечто романтичное, когда люди не знакомые даже с основами электротехники могли зажигать свет с помощью echo. С помощью нового интерфейса такой прямой связи не чувствуется, так как теперь требуются дополнительные утилиты для взаимодействия.

По поводу первого тезиса ничего сказать не могу, никогда не сталкивался с такой необходимостью, в конце концов можно сразу инициализировать контакты как входы или выходы в device tree. Знаю, что данная функциональность пригодилась бы тем кому нужен bit-banging в user-space, но здесь существует одно но, на чистом linux, bit-banging возможен разве что для очень низкочастотных вещей, а так нужeн как минимум PREEMPT_RT patch.

Второй тезис также странен не могу себе представить такой экономии места, что бы было необходимо отключить sysfs.

Третий еще более странен, может просто не надо «краха» приложения?

По поводу четвертого могу сказать, что ничего принципиально почти не поменялось. Если указанный в платформенном драйвере или в device tree label для gpiochip соответствует действительности, то «поиск» несложен, а если они названы «черти-как», то интерфейс здесь уже никак не поможет.

В общем и целом, вразумительного ответа я найти не смог. Я не против нового интерфейса, я даже за него, но такое старательное закапывания старого интерфейса мне лично непонятно и неприятно.