Записки программиста
В уже довольно не новом посте, посвященном Raspberry Pi, это устройство рассматривалось исключительно, как маленький и очень дешевый компьютер. Бесспорно, Raspberry Pi им и является.
Но, помимо этого, у Raspberry Pi есть еще и 26 пинов GPIO (General Purpose Input Output), что очень кстати в свете моего недавнего увлечения электроникой. Почему? Давайте разберемся.<\p>
Отмечу, что все написанное ниже справедливо для Raspberry Pi 2 Model B.
Если у вас другая малина, то расположение пинов и другие детали могут отличаться. Поэтому обязательно сверьтесь с официальной документацией. В качестве операционной системы я использовал релиз Raspbian от 2016-09-28, который можно скачать здесь.
Более поздние релизы мне не нравятся, потому что из соображений безопасности в них решили по умолчанию отключать SSH. Что довольно смешно, потому что в этот же релиз решили включать Adobe Flash.
Итак, расположение пинов описано на официальном сайте:
На этой картинке явно изображен один из углов устройства (слева вверху), поэтому по ошибке пронумеровать пины вверх ногами довольно сложно. Очень интересно, что курили ребята, решившие так нумеровать пины. Если кто-нибудь знает ответ, расскажите, пожалуйста, в комментариях.
Чтобы окончательно всех запутать, они решили сделать две нумерации. Выше представлена «логическая» нумерация. Под этими номерами пины видны операционной системе. Есть еще и «физическая» нумерация, про которую можно прочитать по приведенной выше ссылке.
В рамках данной заметки используется исключительно «логическая» нумерация, изображенная на картинке.
Допустим, мы хотим программно управлять напряжением, подаваемым на 2-й пин. Проще всего это сделать через sysfs.
Первым делом «экспортируем» пин, без этого шага им не получится управлять:
echo 2 > /sys/class/gpio/export
Делаем его out-пином, то есть, он будет либо подавать, либо не подавать напряжение в 3.3 вольта:
echo out > /sys/class/gpio/gpio2/direction
Подаем напряжение:
echo 1 > /sys/class/gpio/gpio2/value
Перестаем подавать напряжение:
echo 0 > /sys/class/gpio/gpio2/value
Узнаем, подается ли сейчас напряжение:
cat /sys/class/gpio/gpio2/value
По завершении работы пину можно сделать unexport:
echo 2 > /sys/class/gpio/unexport
Есть мнение, и не только мое, что 3.3 вольта — как-то маловато. Кроме того, было бы неплохо не только включать и выключать напряжение, но и изменять его в некотором диапазоне. Увы, насколько мне известно, ничего этого Raspberry Pi не умеет. Поговаривают, что умеет Arduino, но опыта использования этого устройства на момент написания этих строк у меня нет.
Можете подключить пин к цепи из светодиода и резистора с сопротивлением 470 Ом и проверить, что описанным выше образом светодиод можно включать и выключать.
Для земли (то есть, минуса) можно использовать любой пин, изображенный на приведенной выше схеме черным цветом. Понятно, что работу с sysfs можно автоматизировать на любом языке программирования по вкусу.
Можно подключить сразу три светодиода разного цвета и получить программно управляемый светофор. Собственно, это я и сделал, воспользовавшись пинами 3 и 4.
Важно! После загрузки Raspberry Pi некоторые пины по дэфолту могут подавать напряжение. Возможно, это не то, чего вы хотите для вашей цепи. У меня по дэфолту ток был на пинах 2, 3 и 14.
Я бы советовал перепроверить эту информацию на вашей конкретной Raspberry Pi и конкретной версии Raspbian. Имейте также в виду, что написанная вами же программа может оставить пины в неизвестном состоянии (например, если вы прибьете ее kill’ом).
Наверное, в общем случае лучше всего проектировать цепь так, чтобы она была готова к любым комбинациям наличия или отсутствия тока на используемых вами пинах.
До сих пор были рассмотрены out-пины. Они как бы «пишут» на макетную плату, но не позволяют узнать ее текущее состояние. Например, нажата ли в настоящих момент какая-то кнопка. Даже если цепь разомкнута, out-пины об этом не знают. Поэтому есть еще и in-пины.
Экспортируем 5-ый пин и делаем его in-пином:
echo 5 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio5/direction
Этот пин я подключил к цепи из резистора сопротивлением 10 кОм и кнопки, которая в нажатом состоянии замыкает цепь, а в отпущенном размыкает.
«Прочитать» кнопку можно так:
cat /sys/class/gpio/gpio5/value
Считывается 1, если кнопка не нажата, то есть, цепь разомкнута, и 0, если кнопка нажата, то есть, цепь замкнута.
В итоге получилась такая конструкция (иллюстрация про кнопку взята отсюда):
А вот и скрипт на Python, который при нажатии на кнопку тушит текущий светодиод и зажигает следующий за ним:
#!/usr/bin/env python
import RPi.GPIO as GPIO
import time
# Use “logical” pin numbers
GPIO.setmode(GPIO.BCM)
# Disable “This channel is already in use” warnings
GPIO.setwarnings(False)
# Setup LED's: 2 – green, 3 – yellow, 4 – red
for i in range(2,5):
GPIO.setup(i, GPIO.OUT)
GPIO.output(i, False)
current_led = 2
GPIO.output(current_led, True)
# Prepare to read button state
BUTTON = 5
PRESSED_CODE = 0
GPIO.setup(BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
# GPIO.wait_for_edge(BUTTON, GPIO.FALLING)
# print(“Button pressed”)
# GPIO.wait_for_edge(BUTTON, GPIO.RISING)
# print(“Button released”)
time.sleep(0.05)
if GPIO.input(BUTTON) == PRESSED_CODE:
GPIO.output(current_led, False)
current_led = max(2, (current_led + 1) % 5)
GPIO.output(current_led, True)
time.sleep(0.1)
Опытным путем удалось подобрать временные задержки, при которых светодиоды переключаются в точности так, как ожидает пользователь. Закомментированный в приведенном коде метод wait_for_edge на практике работает совершенно непредсказуемо. Например, если зажать кнопку на несколько секунд, то последующие нажатия будут приводить к зажиганию светодиодов в каком-то почти случайном порядке.
Насколько мне известно, это по большому счету все, что можно сделать с помощью GPIO на Raspberry Pi. Поправьте, если я не прав.
Дополнение: В комментариях подсказывают, что малина также умеет и ШИМ.
Источник: https://eax.me/raspberry-pi-gpio/
Распиновка Raspberry Pi – нюансы и особенности
В Raspberry Pi встроен GPIO – интерфейс ввода/вывода, к которому можно подключать различные внешние устройства.
Они, в свою очередь, могут работать как на ввод, так и на выход, то есть – принимать сигнал и отправлять его на “Малину” либо делать только что-то одно.
Первое, что нужно знать человеку, желающему наладить взаимодействие одного или нескольких устройств с Raspberry Pi – распиновка.
Содержание
В Raspberry Pi встроен GPIO – интерфейс ввода/вывода, к которому можно подключать различные внешние устройства. Они, в свою очередь, могут работать как на ввод, так и на выход, то есть – принимать сигнал и отправлять его на “Малину” либо делать только что-то одно.
Первое, что нужно знать человеку, желающему наладить взаимодействие одного или нескольких устройств с Raspberry Pi – распиновка. Настоятельно рекомендуется загрузить к себе ее схему, чтобы впоследствии, когда возникнет необходимость, быстро узнать за что отвечает тот или иной пин.
Какие пины присутствуют на Raspberry Pi
У Raspberry распиновка включает в себя два ряда штырьков. Совокупное количество же пинов равняется 40, а значит в одном ряде их числов – 20.
В первую очередь человеку, который хочет подключить внешнее устройство, нужно знать, чем отличается каждый ряд. Первый (располагается слева) предназначается девайсам, для работы которых требуется напряжение в 3,3 Вольта. Второй (соответственно, размещается справа) – 5 Вольт. С этим не должно возникнуть вопросов.
Следующее, что нужно знать о распиновке GPIO Raspberry Pi – назначение всех штырьков. Всего существует три типа пинов:
- питающие (при включении подают электричество);
- порты (выводящие и принимающие информацию);
- заземляющие.
Если посмотреть на схему Raspberry Pi 3 (или другой модели), то можно увидеть, что пины подписаны. Power – это питающие, Ground (иногда пишется GND) – заземляющие, а BCM – непосредственно порты.
Типы портов по номерам
Теперь можно рассмотреть, какой PIN на Rapsberry Pi за что конкретно отвечает.
Первый ряд:
- питающие (Power) – 1 и 17 штырек;
- заземляющие (Ground или RND) – 9, 25 и 39;
- порты (BCM) – все остальные.
Второй ряд (тот, который предназначен для 5-вольтных устройств) Raspberry распиновку имеет немного другую:
- питающие являются смежными – 2, 4 пины;
- заземляющие – 6, 14, 20, 30 и 34;
- порты – все остальные.
Как можно заметить, нумерация в “Малине” выполняется не сверху вниз по рядам, а по горизонтали. То есть: 1 – 3,3V, 2 – 5V, 3 – порт, 4 – 5V, 5 – порт, 6 – заземление, 7 – порт, 8 – первый порт для 5-вольтных устройств и т.д.
Существует два способа нумерации – по порядку и в соответствии с номерами, использующимися в чипе. Это обусловлено тем, что питающие и заземляющие не имеют своих номеров в формате BCM.
Выше указана нумерация по порядку, тогда как второй вариант обозначается буквами BCM. Именно номера BCM используются при написании программ, однако есть исключения.
Например, WiringPi (библиотека для взаимодействия с GPIO) имеет собственную нумерацию. К примеру, 3-у порту, который процессор считает BCM 2, назначает номер WiringPi 8.
При написании кода с применением WiringPi нужно ознакомиться с соответствующей схемой.
Следует отметить, что пины заземления могут использовать любые девайсы (и 3-х, и 5-и вольтный), так как не имеют каких-то отличительных особенностей – в каждом ряду они одинаковые.
Что следует учитывать при работе с GPIO
Можно подключать любые устройства в Raspberry 2, 3 т.д. пины. Однако на GPIO есть специальные порты, которые применять не по назначению возможно, но не рекомендуется. К ним относятся BCM 0 и BCM 1, которые в схеме имеют номера 27 и 28 соответственно. Эти порты предназначены специально для поверхностного монтажа – HAT-устройств, которые, по сути, являются платами расширения.
Также тем, кто планирует работать с GPIO “Малины” рекомендуется следить за силой тока. Максимально через все пины может подаваться электричество в 50мА. При неправильном использовании такая сила может повредить не только внешнее устройство, но и вывести из строя процессор Raspberry.
Возможности пинов Raspberry
Теперь кратко нужно рассмотреть возможности пинов, присутствующих в “Малине”. Первое, о чем следует рассказать – о силе тока.
Максимально на один 3-вольтовый пин может быть подано 16 миллиампер, тогда как суммарно на все, работающие под указанным напряжением – 50 миллиампер.
На 5-вольтовые power-штырьки, в свою очередь, может быть суммарно подано до 500 миллиампер. Благодаря этому по GPIO возможно подключать в том числе клавиатуры, мыши и прочее оборудование.
Любой из пинов-портов может работать в двух режимах: INPUT (вход) и OUTPUT (выход). При этом все, кроме BCM14 и BCM15 по умолчанию сконфигурированы именно на вход, однако это легко можно поправить при написании кода.
При помощи каких языков можно взаимодействовать с пинами
Это возможно сделать при помощи практически любого популярного ЯП:
- C или C++
- Basic
- Python и т. д.
Об особенностях работы с GPIO можно узнать из различных материалов в Сети. Например, это возможно сделать на сайте elinux.org.
Как можно видеть, 40 pin Raspberry Pi освоить не очень трудно. Ее GPIO имеет очень простую структуру.
Но чтобы не запутаться или не забыть назначение портов, и тем самым не спалить плату или внешний девайс, рекомендуется всегда держать при себе соответствующую схему.
А если, в свою очередь, неудобно работать со встроенной GPIO, то можно приобрести плату-расширения. Используя ее, возможно свободно размещать внешние устройства, не беспокоясь, что контакты заденут один или несколько штырьков, расположенных по соседству.
Источник: http://myraspberry.ru/raspinovka-raspberry-pi.html
Raspberry Pi. Работаем с GPIO на Python – Часть 1
Как-то я писал о том, что планирую использовать Raspberry Pi в качестве веб-сервера, управляющего моим устройством. Пришло время задуматься над интерфейсом подключения. У разработчика, желающего подключить свое железо к Raspberry есть два пути: использовать для этого USB или выводы общего назначения (GPIO).
С возможностями USB все приблизительно понятно (в будущем постараюсь написать пост о работе с внешним железом через USB). О GPIO же информации не так много, да и опыта его использования нет. В общем я заинтересовался GPIO и его возможностями.
В статье речь пойдет о выводах общего назначения Raspberry Pi – GPIO:
- возможности GPIO
- распиновка GPIO
- как работать с GPIO на Python
- характеристики GPIO (прежде всего показатели скорости)
- пример использования GPIO Raspberry
Предварительно я наладил удаленную работу с Raspberry Pi через SSH, чтобы каждый раз не подключать монитор и клавиатуру. Поэтому в исходном состоянии у меня к Raspberry подключено всего два “провода”: питание и сетевой кабель для соединения с роутером. Хотя принципиального значения это не имеет: все нижеописанное будет справедливо, как в случае работы с консолью Raspberry через SSH, так и при использовании подключенной клавиатуры.Порт GPIO (сокращение от General Purpose Input Output) – это программно управляемые выводы общего назначения, которые могут работать как входы (для считывания сигнала) или как выходы (для передачи сигнала). На Raspberry Pi они выполнены в виде двух рядов штырьков с шагом в 2,54 мм (разъем PLD). Выражение “общего назначения” означает, что эти выводы пользователь может использовать в своих целях так, как ему захочется, поскольку они не выполняют каких-то определенных жестко заданных функций. При работе с GPIO следует только иметь ввиду, что это цифровые выводы с максимальным уровнем напряжения 3,3 В, соответствующим логической единице. Поэтому программно выводить на GPIO аналоговый сигнал или подавать на него аналоговый сигнал извне для последующий оцифровки нельзя.
Итак, что представляет собой порт GPIO и каковы его возможности? GPIO объединяет в себе 26 выводов, среди которых присутствуют следующие:
- 2 вывода с постоянным уровнем напряжения 5 В
- 2 вывода с постоянным уровнем напряжения 3,3 В
- 5 общих выводов (земля)
- 17 цифровых программно управляемых выводов
Каждый из этих 17 выводов может работать как вход, либо как выход. Однако помимо этого, некоторые из этих выводов могут выполнять альтернативные необязательные функции. Что это значит? Каждый из таких выводов в зависимости от программной настройки могут работать либо как обычный вывод, либо как вывод одного из последовательных интерфейсов. С помощью таких выводов GPIO альтернативно могут реализовываться последовательные интерфейсы I2C, SPI и другие последовательные интерфейсы посредством UART.
Примечание: Это знакомые понятия для тех, кто сталкивался с программированием микроконтроллеров. Для тех, кто не сталкивался и на данном этапе пока желает просто программно выводить “1” и “0” на нужном выводе – знания этих интерфейсов не понадобится. Поэтому не буду здесь уделять этому внимание.
Скажу только, что среди микроконтроллеров и других устройств (различные датчики, АЦП, ЦАП, микросхемы памяти) это очень распространенные интерфейсы, поэтому наличие выводов этих интерфейсов в GPIO Raspberry при необходимости позволяет очень легко и с минимумом программного кода “научить” Raspberry “общаться” с вашим устройством.
Как понять где какой вывод находится? Для этого необходима распиновка (цоколевка) GPIO. В официальной документации приведена распиновка разных версий GPIO Raspberry Pi. Здесь я приведу самую последнюю на данный момент распиновку GPIO – для Raspberry Pi Model B Rev.2:
На схеме в скобках указана альтернативная функция каждого вывода:
- SDA, SCL – выводы интерфейса I2C
- TXD, RXD – выводы UART
- MOSI, MISO, SCLK, CE0, CE1 – выводы интерфейса SPI
- GPCLK0 – (General Purpose Clock) вывод для формирования варьируемой тактовой частоты для внешних устройств
- PCM_CLK, PCM_DOUT – выводы аудио-интерфейса I2S
Пожалуй, это самый важный раздел. Нужно помнить о некоторых особенностях GPIO и соблюдать определенные меры предосторожности, чтобы не залететь еще на 35-50$ не повредить Raspberry. Ниже приведены такие “критические особенности”, а также несколько нюансов, которые просто могут быть полезны, и которые желательно помнить при разработке.
- Максимальный суммарный ток обоих выводов 3.3 В равен 50 мА! Поэтому эти выводы могут использоваться для питания внешних устройств, только если их потребляемый ток меньше 50 мА.
- Максимальный суммарный ток обоих выводов 5 В равен 300 мА! Эти выводы также могут использоваться для питания внешних устройств только в том случае, если их потребляемый ток меньше 300 мА.
- Нельзя на GPIO подавать напряжение больше 3,3 В! Цифровые выводы GPIO имеют уровни напряжения 0 – 3,3 В и не совместимы с традиционными уровнями напряжения 0 – 5В! Поэтому нельзя напрямую соединять Raspberry Pi и цифровые устройства, работающие с TTL-уровнями 5 В. Если подать на GPIO вывод Raspberry логическую единицу, представляющую собой 5 В, а не 3,3 В – вывод может выйти из строя.
- Выводы GPIO 14 и GPIO 15 по-умолчанию выполняют альтернативную функцию и являются выводами UART – RXD и TXD. Поэтому после включения на них присутствует высокий уровень 3,3 В. Программно их можно переконфигурировать в обычные выводы. Все остальные GPIO после включения Raspberry выполняют основную функцию и работают как обычные цифровые выводы.
- Все настраиваемые пины GPIO по-умолчанию являются входами. И поэтому имеют высокое входное сопротивление. При этом подтяжка логического уровня у них не включена, выводы “висят в воздухе”, поэтому после включения Raspberry напряжение на них может “плавать”. Это нормально. Исключением является только 2 следующих вывода:
- Выводы GPIO 0 (SDA) и GPIO 1 (SCL) по-умолчанию “подтянуты” к питанию. Поэтому после включения Raspberry на них присутствует напряжение логической единицы (3,3 В).
- Сигнал на любом из цифровых выводов может служить источником внешнего прерывания. Кто раньше сталкивался с микроконтроллерами поймет, насколько это может быть полезно. Как использовать прерывания в Raspberry Pi – пока это идея для следующего поста.
Пожалуй, все.. Ну и в целом нужно помнить, что GPIO – это выводы, непосредственно подключенные к процессору Raspberry Pi, они являются инструментом для взаимодействия с ним.
Поэтому неосторожное обращение с GPIO может привести к необратимым последствиям для процессора. На этом с “пугалками” заканчиваю.
Главное и простое правило – не подавать больших напряжений и не потреблять большой ток. Переходим к делу.
Примечание: Работать с GPIO, по сути, можно двумя способами:
1) Используя bash и файловую систему Rasbian
Raspbian является одним из дистрибутивов Linux, а концепция Linux предполагает, что любой объект является файлом.
Именно это позволяет выводить и считывать сигналы с GPIO обычными командами оболочки bash прямо в терминале! Вывод логической единицы при этом выглядит как команда записи “1” в файл, соответствующий нужному выводу. Подробные примеры даны здесь.
2) Используя языки программирования (самые разные от C до Бэйсика)
Это более гибкий и более производительный вариант, поскольку он не требует обращения к файловой системе. При этом взаимодействовать с GPIO Raspberry можно на самых разных языках, внушительный список которых приведен здесь вместе с примерами. Ниже разберем пример работы с GPIO на Python.
Предположим нам нужно вывести логическую “1” или “0” на GPIO 7 и считать сигнал с GPIO 8.
0) Для работы с GPIO на Python нужна специальная библиотека RPi.GPIO. Сейчас ее можно установить прямо с репозиториев, а не качать архив и устанавливать вручную, как было раньше. Воспользуемся этой возможностью:
sudo apt-get install python-rpi.gpio (или python3-rpi.gpio для 3-й версии Питона)
Оказывается, в новом дистрибутиве Raspbian она уже установлена, поэтому двигаемся дальше.
0.5) GPIO является системным элементом Raspbian, поэтому работать с ним нужно только под суперпользователем. Будем писать программу прямо в консоли, поэтому запускаем python:
sudo python
1) Импортируем библиотеку для работы с GPIO:
import RPi.GPIO as GPIO
2) Устанавливаем способ нумерации выводов GPIO.
Зачем? Дело в том, что во многих функциях этой библиотеки необходимо указывать номер вывода, над которым мы хотим произвести какую-либо манипуляцию.
Однако указываемый номер можно интерпретировать по-разному: либо это номер GPIO, либо это номер пина (P1-26) на плате Raspberry (см. распиновку). Чтобы не возникало путаницы, сразу после импорта желательно “указать библиотеке”, какую нумерацию мы будем использовать в программе.
GPIO.setmode(GPIO.BCM) #GPIO.BCM – будет использоваться нумерация GPIO
#GPIO.BOARD – будет использоваться нумерация пинов P1-26
3) Конфигурируем выводы
Поскольку мы будем выводить сигналы на GPIO 7, конфигурируем его как выход, а GPIO 8 – как вход:
GPIO.setup(7, GPIO.OUT) #конфигурируем GPIO 7 как выход
GPIO.setup(8, GPIO.IN) #конфигурируем GPIO 8 как вход
Примечание: именно после выполнения этой команды на GPIO 7 установится ровно 0 В, поскольку этот вывод больше не является входом и на нем нет “плавающего” потенциала.
С помощью необязательного параметра pull_up_down функции setup можно также настроить “подтяжку” вывода к питанию или к земле:
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_UP) #подтяжка к питанию 3,3 В
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #подтяжка к земле 0 В
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_OFF) #режим по-умолчанию
4) Формируем и считываем сигналы
Формируем “1” и “0” на GPIO 7 и считываем сигнал с GPIO 8:
GPIO.output(7, True) #выводим на GPIO 7 логическую “1” (3.3 V)
GPIO.output(7, False) #выводим на GPIO 7 логический “0”
signal = GPIO.input(8) #считываем сигнал с GPIO 8 в переменную signal
5) Завершаем работу
После всех нужных операций корректно завершаем работу:
GPIO.cleanup()
Выполнение этой операции приведет к возвращению всех выводов GPIO в первозданное состояние.
Примечание: если не выполнить эту операцию, то даже после закрытия программы и выхода из python, выводы GPIO останутся в том, состоянии, в котором они были на момент завершения.
Это может быть чревато тем, что при попытке повторно поработать с этими выводами будет возникать сообщение, о том, что вывод уже используется: “RuntimeWarning: This channel is already in use, continuing anyway.”
Весь пример целиком:
import RPi.GPIO as GPIO #подключаем библиотеку
GPIO.setmode(GPIO.BCM) #устанавливаем режим нумерации
GPIO.setup(7, GPIO.OUT) #конфигурируем GPIO 7 как выход
GPIO.setup(8, GPIO.IN) #конфигурируем GPIO 8 как вход
GPIO.output(7, True) #выводим на GPIO 7 логическую “1” (3.3 V)
GPIO.output(7, False) #выводим на GPIO 7 логический “0”
signal = GPIO.input(8) #считываем сигнал с GPIO 8 в переменную signal
GPIO.cleanup() #завершаем работу с GPIO
На мой взгляд, из всех характеристик наиболее интересны временные параметры GPIO, а именно – насколько быстро может меняться состояние цифрового вывода из “1” в “0” и обратно, если управлять портом программно. Для проверки этого использовался следующий код:
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(7, GPIO.OUT)
while (1):
GPIO.output(7, True)
GPIO.output(7, False)
Смотрим, что получается на осциллографе, подключенного к выводу 7, при выполнении этого кода:
Итак, программное циклическое переключение цифровых выводов GPIO осуществляется с максимальной частотой ~27 кГц. На второй картинке видно, что в каждом из устойчивых состояний (“1” и “0”) вывод может находится в течение ~ 18-20 мкс. Получить импульсы меньшей длительности с помощью используемых в статье программных средств нельзя.
Примечание: частота импульсов, изображенных на верхних картинках, может незначительно колебаться. Это связано с тем, что Linux на Raspberry многозадачна и не всегда уделяет нашей программе все процессорное время. Также следует иметь ввиду, что добавление дополнительных команд внутрь цикла while может существенно увеличить время каждого импульса.
По нижним картинкам можно оценить время переключения пина GPIO из одного состояния в другое (другими словами длительность переходного процесса) – оно составляет приблизительно 50 нс. Надо сказать, довольно неплохие результаты, однако и конкурировать по скорости с ПЛИС GPIO Raspberry Pi не может.
Примечание: о том, каких длительностей можно добиться с использованием C описано в следующей статье.
Следует иметь ввиду, что те пины GPIO, которые работают в режиме последовательных интерфейсов, позволяют добиться больших скоростей, поскольку при работе последовательных интерфейсов на высоких скоростях процессор аппаратно формирует тактовые частоты и сигналы согласно правилам того или иного последовательного интерфейса. Так, например, с помощью вывода GPCLK0 можно получать импульсы частотой порядка 100 МГц и выше.
Как можно применить все это на практике? Зачем выводить “1” или “0” на GPIO? Например, можно помигать светодиодами! Например, можно управлять силовой нагрузкой и включать / выключать любые бытовые приборы, работающие от сети 220 В. Для этого понадобится Raspberry Pi и всего 7 деталей.
Схема такого программного “выключателя” приведена ниже:
Примечание: микросхема-оптодрайвер MOC3041M имеет гальваническую развязку силовых цепей от слаботочных, поэтому она является “барьером безопасности” между Raspberry и сетью 220 В, выход ее из строя не повредит Raspberry.
Конденсатор C8 должен быть высоковольтным и выдерживать напряжение ~400 В.
Данная схема может коммутировать токи до 16А. Она полностью отлажена, проверена на практике и занимает очень мало места (к сожалению, у меня не сохранились фото устройства, где она используется).
Подача “1” на GPIO 7 Raspberry Pi приведет к срабатыванию оптодрайвера и открытию симистора V2, который начнет пропускать через себя ток, идущий от сети 220 В к силовой нагрузке. Прибор включается.
Как только на GPIO 7 возникает “0” – симистор V2 закрывается и цепь нагрузки размыкается. Прибор выключается. Все просто!
Применение же именно Raspberry Pi позволяет управлять нагрузкой программно, по расписанию, при наступлении каких-либо внешних событий или подаче сигналов (к примеру, сигнал с пульта для открытия ворот) и даже через Интернет (например, посредством собственного веб-сайта, работающего на том же Raspberry). Одним словом, Raspberry помогает развивать фантазию.
На этом все. В следующем посте о Raspberry постараюсь описать работу с UART и SPI.
Источник: http://hexvolt.blogspot.com/2013/02/raspberry-pi-gpio.html
Raspberry Pi. Урок 4. Настройка GPIO | Raspberry Pi в Киеве (Украина)
Скорее всего появится запрос на подтверждение. Нажмите ‘Y’.
I2C — очень распространенный стандарт, который разработан для коммуникации между чипами. Поскольку Raspberry Pi может взаимодействовать с I2C, мы можем подключать множество чипов и модулей с поддержкой I2C.
Шина I2C позволяет множеству устройств подключаться к Raspberry Pi с помощью уникальных адресов, которые можно задавать изменив настройки джамперов на модуле. Очень удобно иметь возможность увидеть какие устройства подключены к Pi. Так можно убедиться, что все работает.
Чтобы это сделать, нужно установить программу i2c-tools с помощью кода:
Запустите sudo raspi-config и следуйте подсказкам, чтобы установить поддержку i2c для ARM core и linux kernel
Теперь перезагрузитесь!
Мы также рекомендуем просмотреть шаги ручной настройки, чтобы удостовериться, что все было сделано raspi-config!
Если Вы используете Occidentalis, то Ваш Pi поддерживает I2C насколько это позволяет аппаратное обеспечение. Однако если у Вас Raspbian, Вам нужно будет открыть LXTerminal, консоль или ssh и ввести следующую команду:
и добавить эти две строки в конце файла:
Теперь сохраните Control-X Y
В зависимости от Вашего дистрибутива, Ваш файл может называться /etc/modprobe.d/raspi-blacklist.conf
Если файл отсутствует, то ничего делать не нужно. Но если он у Вас есть, нужно внести изменения и закомментировать строки:
.. поставив # перед ними.Откройте редактор файла вписав следующее:.. отредактируйте файл так, чтоб он выглядел следующим образом, сохраните и выйдите из файла (CTRL-x и Y).
Если у Вас новая версия Raspberry Pi (ядро 3.18 или выше), Вам также нужно будет обновить файл /boot/config.txt file. Edit it with sudo nano /boot/config.txt и добавить следующий текст внизу:
Обратите внимание, что «1» в»i2c1″ — единица, а не L!
Когда закончите, перезагрузитесь!
После входа введите следующую команду, чтобы увидеть все подключенные устройства (если у Вас 512MB Raspberry Pi Model B)
Это значит, что используются 2 адреса – 0x40 and 0x70.
Если у Вас одна из самых первых версий Raspberry Pi (256MB Raspberry Pi Model B), Вам нужно будет ввести такую команду:
Разработчики Raspberry Pi поменяли местами разъемы I2C. Просто запомните: 512M использует для i2c разъем 1, а 256M разъем 0!
Для начала уберите черный список spi-модуля:
найдите строку:
blacklist spi-bcm2708
и поставьте # в начале. Вот так:
Теперь введите control-X Y, нажмите клавишу ввода и сохраните файл.
Перезагрузитесь sudo reboot
При следующем входе проверьте, что Вы можете видеть устройства с помощью:
Вы должны видеть 2 устройства: по одному на каждую SPI шину
Лучший способ протестировать то, что Вы сделали — это сделать какой-нибудь проект (желательно начать с чего-то попроще).
Источник: http://raspberry.com.ua/raspberry-pi-lesson-4/
Что нужно знать о портах ввода-вывода Raspberry Pi. Часть 2
| Рисунок 11. | Кнопка подключена к разъему GPIO платы RPi. |
Принципиальная схема подключения кнопки изображена на Рисунке 12. Обратите внимание, что на макетной плате остается подключенным и светодиод из примера в первой части статьи, но на текущей схеме он не показан.
| Рисунок 12. | Схема подключения кнопки к разъему GPIO. |
Как видно из схемы, если кнопка не нажата, вход GPIO5 будет подключен через резистор к шине 3.3 В. Входной порт RPi имеет высокое входное сопротивление, поэтому напряжение на входной линии будет близко к 3.3 В. Это означает, что при отпущенной кнопке RPi будет определять состояние входа как «лог. 1». Когда кнопка нажата, напряжение на входе будет равно 0 В, что является «лог. 0».
Для этой простой схемы величина сопротивления резистора R1 некритична и может находиться в диапазоне от 1 кОм до 47 кОм, однако низких значений следует избегать, поскольку в этом случае увеличивается ток, потребляемый при нажатии кнопки.
Исходный код программы для чтения состояния кнопки доступен в разделе загрузок (файл с именем Listing_4(Button).txt). Сохраните код в файле с именем button-test.py и запустите на выполнение командой
sudo python button-test.py.
Результат выполнения программы выводится на экран в виде сообщения о текущем состоянии кнопки и количестве нажатий на нее. При выполнении этого примера вы заметите, что иногда значение счетчика становится больше реального количества нажатий на кнопку, и это происходит из-за «дребезга» контактов.
Примерно то же самое происходит и при отпускании кнопки. Решение состоит в использовании механизма подавления «дребезга» контактов (debouncing). Этот механизм может быть как аппаратным, так и программным, причем последний распространен больше.
В исходном коде, приведенном в файле Listing_5(Button_Debounce).txt, подавление дребезга контактов кнопки реализовано, и подсчет количества нажатий кнопки будет более точным.
Единственное отличие от предыдущего кода заключается в том, что теперь с задержкой 20 мс выполняется вторая проверка состояния входа – за это время дребезг контактов прекращается.
Еще один пример: вольтметр
Как известно, платы RPi имеют только цифровые порты ввода/вывода, но в реальном мире используются аналоговые величины, которые, возможно, необходимо измерять, или контролировать. В следующем примере демонстрируется преобразование аналоговой величины в цифровой сигнал, который можно прочитать с помощью входов RPi.
| Рисунок 13. | Принципиальная схема вольтметра для измерениянапряжения с помощью RPi. |
Примером может служить очень простой, но точный вольтметр с диапазоном измерений 0 … 1 В (Рисунки 13, 14). Учтите, что заменить портативный мультиметр он не может, поскольку не имеет необходимых цепей защиты, и может выйти из строя сам или повредить плату RPi, если используется для чего-либо, выходящего за рамки описанных здесь примеров.
| Рисунок 14. | Схема вольтметра, собранная на макетной плате. |
В схеме используется микросхема AD654 (преобразователь напряжение-частота), которая генерирует прямоугольные импульсы с частотой, зависящей от входного напряжения. Цифровой выход Fout микросхемы подключен к входу GPIO5 (вывод 29 разъема GPIO).
Максимальная частота прямоугольных импульсов при указанных на схеме номиналах элементов равна 10 кГц, поэтому для определения входного напряжения нам потребуется точная система отсчета времени. Код для этого примера (файл Listing_6(Voltmeter).
txt) написан на Си и использует библиотеку wiringpi, написанную Гордоном Хендерсоном (Gordon Henderson). Прежде всего, установите библиотеку wiringpi, для чего выполните следующие команды:
mkdir development cd development git clone git://git.drogon.net/wiringPi cd wiringPi
./build
Сохраните код в файле с именем voltmeter.c и скомпилируйте его командой
gcc -o voltmeter -lrt -lwiringPi voltmeter.c.
Чтобы запустить программу, выполните следующую команду:
sudo ./voltmeter.
Для повышения точности измерений в программе используется усреднение данных. Длительность входных прямоугольных импульсов быстро измеряется 64 раза, затем полученные значения суммируются и делятся на 64. По окончании вычислений включается задержка на одну секунду для выполнения других процессов, и затем цикл измерения повторяется
Несколько элементов в схеме вольтметра также влияют на точность измерений.
Конденсатор С1 и резистор R1 задают характеристики преобразования, поэтому желательно выбрать пленочный полипропиленовый конденсатор и точный резистор с допуском 1%. Можно использовать подстроечный резистор.
Напряжение питания схемы 5 В поступает с разъема GPIO, но его реальное значение может несколько отличаться от 5 В, поэтому лучше использовать отдельный более точный источник питания.
Для быстрой проверки схемы можно использовать делитель напряжения, состоящий из двух резисторов. Схема включения делителя показана в левой части схемы вольтметра (Рисунок 12).
Если резисторы прецизионные и напряжение питания в точности равно 5 В, расчет напряжения на выходе делителя дает 0.04950 В. Значение, полученное в результате реального программного измерения, составило 0.04991 В.
Неплохо для такого простого проекта!
Диоды Шоттки D1 и D2 в схеме не являются обязательными, но настоятельно рекомендуются, поскольку они обеспечат некоторую защиту микросхемы, если случайно на вход будет подано напряжение вне диапазона 0…1 В.
Советы, касающиеся использования входов
Защищенные входы
RPi можно защитить от случайного попадания высокого напряжения, добавив к используемым входам дополнительную схему.
В некоторых случаях очень хорошей и недорогой альтернативой показанной ниже схеме (Рисунок 15) может служить оптрон, способный защитить входы RPi от напряжений до 60 В и справится с переполюсовкой.
Транзистор BC547B в схеме на Рисунке 14 можно заменить на 2N3904 или BC549. Допустимая мощность рассеивания резистора R1 может быть 0.25 Вт при входных напряжениях до 50 В, в противном случае лучше использовать 0.5 Вт.
| Рисунок 15. | Дополнительная схема для защиты входов RPi. |
Схема инвертирует входной сигнал, переключаясь в «лог. 0» при входном напряжении свыше 2 В.
Подключение к 5-вольтовй логике
Прямое подключение устройств с 5-вольтовыми логическими выходами к входам RPi может вывести плату из строя. В этом случае есть множество решений.
Если состояние 5-вольтового логического выхода меняется относительно медленно, можно рассмотреть возможность использования резистивного делителя на входе RPi, но к быстрым схемам такой способ не применим.
Тогда намного более хорошим решением будет использование буферной микросхемы. Для средних скоростей (до 100 кГц) вполне подойдет схема на N-канальном MOSFET ZVN2110A (Рисунок 16).
Эта схема также инвертирует входной сигнал.
| Рисунок 16. | Схема простого преобразователя логических уровней. |
Показанный на схеме транзистор можно заменить на ZVNL120A или VN10LP.
При пайке полевых транзисторов следует соблюдать основные меры предосторожности. При сборке устройства сначала установите резистор R3 и только после этого извлеките MOSFET из защитной упаковки и запаяйте в схему. Резистор R3 обеспечит некоторую защиту.
Скорость работы и джиттер
Опрос состояния кнопок и управление светодиодами – события относительно медленные, измеряющиеся десятками и сотнями миллисекунд. Иногда встречаются намного более высокоскоростные сигналы.
Например, пульт от телевизора излучает инфракрасные световые импульсы со скоростью 40 тыс. раз в секунду.
Несмотря на то, что основной процессор RPi работает на частоте 1 ГГц, работа подсистемы ввода/вывода с такой скоростью не поддерживается по ряду причин, как аппаратных, так и программных. Мы рассмотрим некоторые программные аспекты, касающиеся темы статьи.
RPi работает под управлением многозадачной операционной системы (ОС) Linux. Система может превентивно забирать контроль над вашей программой для выполнения других задач.
Все это происходит довольно быстро, так что кажется, будто мышка по-прежнему работает во время выполнения вашей программы, но на самом деле вашей программе и коду драйвера мыши ОС предоставляет лишь короткие промежутки времени.
Обычно это не имеет значения, но когда вам нужна обработка коротких или высокоточных событий, это может стать проблемой, проявляющейся (например) в виде джиттера.
Кроме того, немаловажное значение имеет выбор языка программирования, поскольку некоторые библиотеки подходят лучше, чем другие. Интерпретированные и компилированные коды могут выполняться с разными скоростями.
Короче говоря, если требуется очень точная временнáя привязка событий, возможно, придется написать драйвер Linux или использовать внешнее оборудование (например, другой микроконтроллер или логические схемы и генератор).
Одним из хороших вопросов, важных для более полного использования возможностей RPi, является то, насколько быстро можно изменять логические состояния выходов GPIO с помощью библиотек Python, Си и описанного выше командного скрипта.
Чтобы узнать это, был написан код для периодического переключения логического состояния выходного порта, к которому был подключен осциллограф. Результат представлен в Таблице 1.
| Таблица 1. | Максимальная частота переключения выходов прииспользовании различных языков программирования | |||||||||||||||
|
Однако всегда важно помнить о джиттере, которым обязательно сопровождается работа ОС Linux. Для случая простого переключения светодиода это, кончено же, не проблема.
Характер джиттера можно увидеть на осциллографе в режиме наложения нескольких каналов при синхронизации общим сигналом (Рисунок 17).
Обратите внимание, что джиттер может принимать множество значений, несмотря на то, что сигналы дискретно разнесены на 4 нс (250 МГц), что связано с аппаратными особенностями RPi.
| Рисунок 17. | Следствием использования ОС Linux становитсяджиттер выходного сигнала. |
Заключение
Теперь вы увидели, что 40-контактный разъем GPIO на платах RPi может использоваться для различных проектов – от управления светодиодами до электронных схем для измерения аналоговых величин.
С небольшими дополнительными схемами адаптации логических уровней RPi может взаимодействовать 5-вольтовыми устройствами.
С помощью Python очень легко управлять выходами, так же как не представляет сложности и чтение состояния входов, а библиотека wiringpi значительно упрощает управление программистам, использующим Си.
Загрузки
- Исходные коды примеров программ ко второй части статьи
Источник: https://www.rlocman.ru/shem/schematics.html?di=336041
Как использовать прерывания с Python на Raspberry Pi и RPi.GPIO
Последняя большая новость в мире Кфізиуккн Pi Python GPIO программирования является то, что Бен Кростон выпустил обновление для RPi.GPIO. Почему это важно? Потому что эта версия имеет прерывания. “Что за прерывания?” Скажете Вы. Это способ ждать чего-то, не проверяя постоянно происходит это или нет.
Представьте, что вы ждете доставки – что нибудь такое, что вас действительно очень волнует – как Pi камера.Вы проводите слишком много времени, глядя на улицу в нетерпеливом ожидании прибытия почтальона. Вы не можете полностью сосредоточиться на том, что вы должны делать, потому что вы знаете, что это неизбежно. Каждый раз, когда вы слышите что-то на улице, вы подрываетесь и смотрите в окно.
То, что я только что описал в человеческих терминах это немного похоже на опрос. Опрос постоянно проверяет что-то.
Например, если вы хотите проверить, что ваша программа действительно реагирует на нажатие кнопки как можно быстрее, вы можете проверять состояние кнопки около десяти тысяч раз в секунду.
Это замечательно, если вам нужно быстро реагировать, но такая проверка использует очень немного вычислительной мощности компьютера. Таким же образом, как вы не можете полностью сосредоточиться, когда вы ожидаете доставку, большая часть вашего процессора используется этим опросом.
Но должен же быть лучший способ, верно?
Да. Так и есть. Это прерывания. Это первая из серии статей, которые призваны показать вам, как использовать эту новую возможность в Python.
Прерывания гораздо более эффективный способ обработки “ждать чего-то и реагировать немедленно, когда это произойдет” ситуации. Они высвободждают ресурсы используемые впустую на опрос, так что вы можете использовать их для чего-то еще. Затем, когда происходит ожидаемое событие, остальная часть вашей программы “прерывется” и выполняются указаные для события действия.
Таким образом, чтобы перенести на человеческий пример …
Прерывание, это как с автоматический детектор почтальона, который скажет вам точно, когда почтальон приходит, так что вы можете отвлечся на что-нибудь другое. Теперь вы точно знаете, что не пропустите важного для вас события.
Так что прерывания это очень полезная возможность, так как вы можете настроить их ждать определенного события, не тратя ресурсы системы.
Итак, как их использовать?
Я собираюсь показать простую ситуацию-“ждать нажатия кнопки”. Но прежде, чем вы попробуете это повторить, проверьте версию RPi.GPIO пакета. Возможно эго прдется обновить. Вы можете проверить, какая версия RPi.GPIO у вас в командной строке с …
sudo python import RPi.GPIO as GPIO
GPIO.VERSION
Это должно показать вам, какая версия RPi.GPIO установлена у вас. Вам нужна 0.5.1 или выше для этого примера.
Установите RPi.GPIO версию 0.5.1 для простых прерываний Если вам нужно, вы можете установить 0.5.1 или более поздние версии sudo apt-get update
sudo apt-get dist-upgrade
(Это обновит все ваши Raspbian пакеты и может занять около часа)
или, с командной строке (это обновит только RPi.GPIO) …
Источник: http://academicfox.com/kak-yspolzovat-preryivanyya-s-python-na-raspberry-pi-y-rpi-gpio/
Малина PI и GPIO булавки: Управление LED с Bash и Python
В предыдущем посту, мы видели были контакты GPIO и некоторые примеры практического применения, Сегодня мы сосредоточимся на операции контакты общего назначения, и научиться управлять ими с переводчика заказов Баш и с Python.
Будет использовать СВЕТОДИОД, сопротивление 330 ом, Проволока, и один Макет, или припой и паяльник.
Мы также должны будем нашей Малина уже Raspbian предварительно установленной, Если ваш случай не является, Вы можете увидеть, как это сделать Следующие ссылки из Каталог.
Езда цепи
Вы можете припаять напрямую СВЕТОДИОД Проволока и сопротивление как вы увидите в следующих Диаграмма, Хотя это гораздо лучше использовать Макет; Также очень важно выглядеть хорошо на висках, как и в “Диагональ” внутри диод СВЕТОДИОД объединяя два контакта для монтирования цепи, уже что если вы смонтировать его обратно не включается.
Цепи, необходимые для управления питанием LED диод.
Я буду использовать один Макет, и я рекомендую вам использовать, Есть некоторые от приблизительно €4 и они позволяют повторно использовать компоненты снова и снова без необходимости паять их, внутренние соединения одного Макет они имеют тенденцию быть следующие.
Макет соединения.
Соединения между Макет и Малина они должны быть, как показано на следующем рисунке, в GPIO Вы можете добраться до вопроса 3,3V Чтобы назначить логический высокое значение.
Цепи, необходимые для управления питанием LED диод.
Привет мир GPIO с Bash
Однажды навесные цепи, Мы будем делать, что я называю “Привет мир GPIO” в Баш выполнение следующих сценарий.
#!/bin/bash #Exportamos el puerto GPIO 17 echo 17 > /sys/class/gpio/export #Lo configuramos como salida echo out > /sys/class/gpio/gpio17/direction #Encendemos el LED asignandole 1 como valor lógico echo 1 > /sys/class/gpio/gpio17/value
Чтобы выключить светодиод, мы можем сделать это следующим сценарий.
#!/bin/bash #Apagamos el LED asignandole 0 como valor lógico echo 0 > /sys/class/gpio/gpio17/value #Eliminamos la entrada del puerto GPIO 17 echo 17 > /sys/class/gpio/unexport
В основном, что мы делаем с Баш является создание Иерархия каталогов в /sys/класса/gpio и добавление содержимого каждого файла, который будет рассматриваться как переменная.
Иерархии в /sys/class/gpio каталога.
Введение в Python
Мы уже доказали, что наша схема работает правильно и СВЕТОДИОД оно было инициировано дать логическое высокое значение переменной, Теперь давайте посмотрим, как мы можем сделать то же самое Python, Это позволит нам наметить наши веб-приложения для управления входы и выходы GPIO с любого устройства.
Операции с использованием веб-приложения.
Прежде чем приступить, Я рекомендую, что вы видите главы 1 для 10 из Это видео учебник от Python канал YouTube из Кода облегчает, Если как у меня не много идея программирования в Python, Оно может прийти к вам очень хорошо для ознакомления с кодом, который мы будем видеть больше вперед и понять его.
Различные схемы контактов GPIO (Совет и BCM)
Существует два типа нумерации ПИН, физические нумерации или режим СОВЕТ, и нумерация чипSoC Broadcom контроль за ними, Мы собираемся использовать Цоколевка в режиме BCM, Но давайте посмотрим на разницу.
Привет мир GPIO с Python
После просмотра видео, и различные выводы уже можно понять основной код, чтобы сделать “Привет мир GPIO” в Python.
Сначала мы собираемся скачать все, что вам нужно для управления GPIO с Python, в Raspbian они уже установлены Python и библиотеки GPIO, но мы собираемся установить дополнительный пакет и обновления системы, чтобы иметь самую последнюю версию.
usuario@maquina:~$ sudo apt-get install python-dev usuario@maquina:~$ sudo apt-get install python-rpi.gpio usuario@maquina:~$ sudo apt-get update && sudo apt-get upgrade
Обновление один раз, Давайте посмотрим, как включить СВЕТОДИОД с следующие сценарий, Например, можно вызвать enciende.py, и мы можем запустить его как root с помощью команды “sudo Python enciende.py”.
#!usr/bin/env/ python #enciende.py #importamos la libreria GPIO import RPi.GPIO as GPIO #Definimos el modo BCM GPIO.setmode(GPIO.BCM) #Ahora definimos el pin GPIO 17 como salida GPIO.setup(17, GPIO.OUT) #Y le damos un valor logico alto para encender el LED GPIO.output(17, GPIO.HIGH)
С этим мы можем отключить его, Например, вызов APAGA.py
#!usr/bin/env/ python #apaga.py #importamos la libreria GPIO import RPi.GPIO as GPIO #Definimos el modo BCM GPIO.setmode(GPIO.BCM) #Ahora definimos el pin GPIO 17 como salida GPIO.setup(17, GPIO.OUT) #Y le damos un valor logico bajo para apagar el LED GPIO.output(17, GPIO.LOW) #Finalmente liberamos todos los pines GPIO, es decir, los desconfiguramos) GPIO.cleanup()
И с этим мы позвоним вам parpadea.py, Мы сделаем мигает СВЕТОДИОД.
#!usr/bin/env/ python #parpadea.py #importamos la libreria GPIO import RPi.GPIO as GPIO #Importamos la libreria time import time #Definimos el modo BCM GPIO.setmode(GPIO.BCM) #Ahora definimos el pin GPIO 17 como salida GPIO.setup(17, GPIO.OUT) #Queremos que lo que contenga el for i in range se repita 5 veces for i in range(0,5): #Asignamos valor logico alto para encenderlo GPIO.output(17, GPIO.HIGH) #Esperamos un segundo time.sleep(1) #Asignamos valor logico bajo para apagarlo GPIO.output(17, GPIO.LOW) #Esperamos un segundo time.sleep(1) #Una vez termina las 5 repeticiones, liberamos el pin GPIO utilizado; en este caso el 17 GPIO.cleanup()
Если вы не импортировать в библиотеку “время“, не могу добавить “Сон“, и если не добавить “Сон” между второй и, Это вполне возможно, что наш глаз не будет воспринимать мерцания.
Это очень важно, чтобы не добавлять специальные символы в скрипты в Python, по этой причине комментарии не переносите акценты, Поскольку он дал характера ошибки недопустимого.
В следующую запись Мы увидим, как сделать простой Веб-приложения Позвольте нам выполнить эти скрипты, чтобы иметь возможность контролировать его с помощью любого устройства с браузером Веб.
Источник: http://www.peatonet.com/ru/raspberry-pi-y-los-pines-gpio-controlando-un-led-con-bash-y-con-python/
Загрузка...