Распиновка gpio на raspberry pi 3

Summary

As you can see, it is quite easy to use http.server to create a simple web server and integrate your plain Raspberry Pi code with the http.server implementation. Our customised BaseHTTPRequestHandler implementation MyServer class can be easily modified to integrate whatever GET or POST requests that you need to get information from Raspberry Pi, or control GPIO via a web site based on your Raspberry Pi project. No Flask web framework is required and no installation of LAMP is required, at least, not for simple IoT project like this one.

The complete codes two python examples available at my github.

https://youtube.com/watch?v=SRf6HW_b3EE

Gpiozero

A newer GPIO library for the Raspberry Pi is gpiozero . Created by Ben Nuttall of the Raspberry Pi Foundation and other contributors it is released under an MIT-type free software license.

While newer than Rpi.GPIO, it is now generally recommended to use it for new programming. It can have a longer learning because it offers more features that Rpi.GPIO, but the resulting code is usually very clean and readable.

We’ll look at a few simple examples of how to use it.

Documentation is excellent, and presents many «recipes» showing how to control various devices from LEDs to switches to motion sensors, servers, and robots.

Gpiozero should be installed by default on Raspian Linux unless you installed the «lite» version. If needed, it can be installed using the command:

sudo apt install python3-gpiozero

Gpiozero provides may different modules or «interfaces». You typically import the ones you use by name so you can refer to them with a short name. For example:

from gpiozero import LED

to allow using the gpiozero.LED module and refer to it as «LED». You can import multiple modules with one import statement, e.g.

from gpiozero import LED, Button

The GPiozero library uses Broadcom (BCM) pin numbering rather than physical pin numbers. That should not normally be a problem. It does define names based on other naming conventions like physical pins that can be used and will be converted to the BCM names. The following examples will all work for an LED that is on GPIO 17 on physical pin 11:

led = LED(17)
led = LED(«GPIO17»)
led = LED(«BCM17»)
led = LED(«BOARD11»)
led = LED(«WPI0»)
led = LED(«J8:11»)

A handy command line tool called «pinout» is part of the library and will graphically show you the GPIO pins for the board it is running on (or any board revision that you specify):

The library is oriented around device and sensor types rather than inputs and outputs. For driving an output connected to an LED, for example, you use the LED module. You create an instance by passing the GPIO name. You can then call various methods like on() and off(). Here is a simple example that flashes and LED:

#!/usr/bin/python3

from gpiozero import LED
from time import sleep

led = LED(24)

while True:
led.on()
sleep(1)
led.off()
sleep(1)

The above loop could also be done by simply calling:

red.blink()

Which blinks an LED, defaulting to a rate of one second on and one second off.

Inputs pins are often connected to buttons, and in this case you can use the Gpiozero Button module, as in this example:

#!/usr/bin/python3

from gpiozero import Button
from time import sleep

button = Button(6)

while True:
if button.is_pressed:
print(«Button is pressed»)
else:
print(«Button is not pressed»)

sleep(1)

We can easily connect a switch so that when a pressed or released event occurs, we drive an LED high or low. This is event drived, so once set up, this works without any polling or further processing:

#!/usr/bin/python3

from gpiozero import LED, Button
from signal import pause

led = LED(24)
button = Button(6)

button.when_pressed = led.on
button.when_released = led.off

pause()

The call to pause() ensures that our Python program does not exit immediately, but rather keeps running until the user interrupts it with Control-C or similar.

Gpiozero has support for many devices — you can explore the documentation and try writing programs of your own. You can also extend it for new types of devices and sensors.

Скорость работы и джиттер

Опрос состояния кнопок и управление светодиодами – события относительно медленные, измеряющиеся десятками и сотнями миллисекунд. Иногда встречаются намного более высокоскоростные сигналы. Например, пульт от телевизора излучает инфракрасные световые импульсы со скоростью 40 тыс. раз в секунду. Несмотря на то, что основной процессор RPi работает на частоте 1 ГГц, работа подсистемы ввода/вывода с такой скоростью не поддерживается по ряду причин, как аппаратных, так и программных. Мы рассмотрим некоторые программные аспекты, касающиеся темы статьи.

RPi работает под управлением многозадачной операционной системы (ОС) Linux. Система может превентивно забирать контроль над вашей программой для выполнения других задач. Все это происходит довольно быстро, так что кажется, будто мышка по-прежнему работает во время выполнения вашей программы, но на самом деле вашей программе и коду драйвера мыши ОС предоставляет лишь короткие промежутки времени.

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

Кроме того, немаловажное значение имеет выбор языка программирования, поскольку некоторые библиотеки подходят лучше, чем другие. Интерпретированные и компилированные коды могут выполняться с разными скоростями

Короче говоря, если требуется очень точная временнáя привязка событий, возможно, придется написать драйвер Linux или использовать внешнее оборудование (например, другой микроконтроллер или логические схемы и генератор).

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

Чтобы узнать это, был написан код для периодического переключения логического состояния выходного порта, к которому был подключен осциллограф. Результат представлен в Таблице 1.

Таблица 1.

Максимальная частота переключения выходов при
использовании различных языков программирования

Язык программирования	Частота	Длительность высокого уровня	Длительность низкого уровня
Python	71.2 кГц	3.9 мкс	10.1 мкс
Си	5.8 МГц	85 нс	85 нс
Командный скрипт	3.9 кГц	115 мкс	139 мкс

Однако всегда важно помнить о джиттере, которым обязательно сопровождается работа ОС Linux. Для случая простого переключения светодиода это, кончено же, не проблема

Характер джиттера можно увидеть на осциллографе в режиме наложения нескольких каналов при синхронизации общим сигналом (Рисунок 17)

Обратите внимание, что джиттер может принимать множество значений, несмотря на то, что сигналы дискретно разнесены на 4 нс (250 МГц), что связано с аппаратными особенностями RPi


Рисунок 17.	Следствием использования ОС Linux становится джиттер выходного сигнала.

Usage

Below is example usage on a Raspberry PI Model B+ V1.2.

To detect/list GPIO character devices:

# gpiodetect
gpiochip0  (54 lines)

To list the I/O lines available on this device:

# gpioinfo pinctrl-bcm2835
gpiochip0 - 54 lines:
        line   0:       "SDA0"       unused   input  active-high
        line   1:       "SCL0"       unused   input  active-high
        line   2:       "SDA1"       unused   input  active-high
        line   3:       "SCL1"       unused   input  active-high
        line   4:  "GPIO_GCLK"       unused   input  active-high
        line   5:  "CAM_GPIO1"       unused   input  active-high
        line   6:    "LAN_RUN"       unused   input  active-high
        line   7:  "SPI_CE1_N"       unused   input  active-high
        line   8:  "SPI_CE0_N"       unused   input  active-high
        line   9:   "SPI_MISO"       unused   input  active-high
        line  10:   "SPI_MOSI"       unused   input  active-high
        line  11:   "SPI_SCLK"       unused   input  active-high
        line  12:         "NC"       unused   input  active-high
        line  13:         "NC"       unused   input  active-high
        line  14:       "TXD0"       unused   input  active-high
        line  15:       "RXD0"       unused   input  active-high
        line  16: "STATUS_LED_N" "ACT" output active-low 
        line  17:     "GPIO17"       unused   input  active-high
        line  18:     "GPIO18"       unused   input  active-high
        line  19:         "NC"       unused   input  active-high
        line  20:         "NC"       unused   input  active-high
        line  21:     "GPIO21"       unused   input  active-high
        line  22:     "GPIO22"       unused   input  active-high
        line  23:     "GPIO23"       unused   input  active-high
        line  24:     "GPIO24"       unused   input  active-high
        line  25:     "GPIO25"       unused  output  active-high
        line  26:         "NC"       unused   input  active-high
        line  27:  "CAM_GPIO0"       unused   input  active-high
        line  28:    "CONFIG0"       unused   input  active-high
        line  29:    "CONFIG1"       unused   input  active-high
        line  30:    "CONFIG2"       unused   input  active-high
        line  31:    "CONFIG3"       unused   input  active-high
        line  32:         "NC"       unused   input  active-high
        line  33:         "NC"       unused   input  active-high
        line  34:         "NC"       unused   input  active-high
        line  35:         "NC"       unused   input  active-high
        line  36:         "NC"       unused   input  active-high
        line  37:         "NC"       unused   input  active-high
        line  38:         "NC"       unused   input  active-high
        line  39:         "NC"       unused   input  active-high
        line  40:   "PWM0_OUT"       unused   input  active-high
        line  41:         "NC"       unused   input  active-high
        line  42:         "NC"       unused   input  active-high
        line  43:         "NC"       unused   input  active-high
        line  44:         "NC"       unused   input  active-high
        line  45:   "PWM1_OUT"       unused   input  active-high
        line  46: "HDMI_HPD_P"       unused   input  active-high
        line  47: "SD_CARD_DET"      unused   input  active-high
        line  48:   "SD_CLK_R"       unused   input  active-high
        line  49:   "SD_CMD_R"       unused   input  active-high
        line  50: "SD_DATA0_R"       unused   input  active-high
        line  51: "SD_DATA1_R"       unused   input  active-high
        line  52: "SD_DATA2_R"       unused   input  active-high
        line  53: "SD_DATA3_R"       unused   input  active-high

Display help for the gpioset command:

# gpioset --help
Usage: gpioset   = = ...
Set GPIO line values of a GPIO chip
Options:
  -h, --help:           display this message and exit
  -v, --version:        display the version and exit
  -l, --active-low:     set the line active state to low
  -m, --mode= (defaults to 'exit'):
                tell the program what to do after setting values
  -s, --sec=SEC:        specify the number of seconds to wait (only valid for --mode=time)
  -u, --usec=USEC:      specify the number of microseconds to wait (only valid for --mode=time)
  -b, --background:     after setting values: detach from the controlling terminal

Modes:
  exit:         set values and exit immediately
  wait:         set values and wait for user to press ENTER
  time:         set values and sleep for a specified amount of time
  signal:       set values and wait for SIGINT or SIGTERM

To toggle GPIO25 high for 1 second:

# gpioset --mode=time --sec=1 pinctrl-bcm2835 25=1

Подключение к 5-вольтовй логике

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

Если состояние 5-вольтового логического выхода меняется относительно медленно, можно рассмотреть возможность использования резистивного делителя на входе RPi, но к быстрым схемам такой способ не применим. Тогда намного более хорошим решением будет использование буферной микросхемы. Для средних скоростей (до 100 кГц) вполне подойдет схема на N-канальном MOSFET ZVN2110A (Рисунок 16). Эта схема также инвертирует входной сигнал.


Рисунок 16.	Схема простого преобразователя логических уровней.

Показанный на схеме транзистор можно заменить на ZVNL120A или VN10LP.

При пайке полевых транзисторов следует соблюдать основные меры предосторожности. При сборке устройства сначала установите резистор R3 и только после этого извлеките MOSFET из защитной упаковки и запаяйте в схему

Резистор R3 обеспечит некоторую защиту.

Practice circuit 2

Fix a two-legged button switch on the breadboard. Now, connect one leg of the switch to any GPIO pin, say Pin 7, and connect the other to any 3.3V pin.

#!/usr/bin/python3
import RPi.GPIO as GPIO
import time

cnl = 7
GPIO.setmode(GPIO.BOARD)

# PIN 7 AND 3.3V
# normally 0 when connected 1
GPIO.setup(cnl, GPIO.IN, GPIO.PUD_DOWN)
try:
while(True):
print(GPIO.input(cnl))
time.sleep(1)
except KeyboardInterrupt:
GPIO.cleanup()
print(“Exiting”)

When this program is run, it will print 0 continuously, and when the switch is pressed down (when the circuit is closed) the output will be 1.

Now change the circuit a little. Remove the connection from the 3v3 pin and connect it to any ground pin. Change the program by replacing GPIO.PUD_DOWN with GPIO.PUD_UP. Now run the program, and 1 will be printed continuously. When the switch is pressed down, the output will be 0.

Interrupts

There is a problem with simple input pins, which is that the programmer has to constantly check the input data. To overcome this, we have interrupts known as ‘event-detect’ and a pin can be made to listen to events by calling:

GPIO.add_event_detect(channel, event, callback = my_callback, bouncetime = timeinmilliseconds)

Channel should be an input pin. The various events available are GPIO.RISING for the rising edge (when the signal changes to HIGH from LOW), GPIO.FALLING for the falling edge (when the signal changes from HIGH to LOW), and GPIO.BOTH for both rising and falling edges. The my_callback method contains the interrupt handling code, and will be executed as a separate thread. bouncetime is the minimum amount of time required between two events. If two events occur in succession, within the bouncetime limit, then the second event will be ignored.

Extra Credit: Blinking Light

Here is a slightly more advanced script that blinks the led on and off. The only real difference is that we are gathering user input and using the sleep function to set the amount of time the light is on or off.

Type the following code into the window:

import RPi.GPIO as GPIO ## Import GPIO library
import time ## Import ‘time’ library. Allows us to use ‘sleep’
GPIO.setmode(GPIO.BOARD) ## Use board pin numbering
GPIO.setup(7, GPIO.OUT) ## Setup GPIO Pin 7 to OUT##Define a function named Blink()
def Blink(numTimes,speed):for i in range(0,numTimes):## Run loop numTimesprint «Iteration » + str(i+1)## Print current loopGPIO.output(7,True)## Switch on pin 7time.sleep(speed)## WaitGPIO.output(7,False)## Switch off pin 7time.sleep(speed)## Waitprint «Done» ## When loop is complete, print «Done»GPIO.cleanup()## Ask user for total number of blinks and length of each blink
iterations = raw_input(«Enter total number of times to blink: «)
speed = raw_input(«Enter length of each blink(seconds): «)## Start Blink() function. Convert user input from strings to numeric data types and pass to Blink() as parameters
Blink(int(iterations),float(speed))

…or you may download the completed script here.

Keep in mind that indentation is very important when writing Python code. Use the TAB key to match the formatting of the above code as you write it.

Télécharger la vidéo, regarder gratuitement