Главная › Настройки › Raspberry pi 3 model b программирование. Программирование Raspberry Pi GPIO на языке Python. Программа для мигания светодиодом на Raspberry Pi

Raspberry pi 3 model b программирование. Программирование Raspberry Pi GPIO на языке Python. Программа для мигания светодиодом на Raspberry Pi

Raspberry PI - это устройство имеющее достаточную производительность для того чтобы на его основе могли быть построены роботы способные распознавать образы, выполнять работу людей и прочие подобные устройства для автоматизации и выполнения сложных вычислительных действий. Т.к. тактовая частота процессора Raspberry PI 3 м.б. 1.2 ГГц а его разрядность 32 бита то Raspberry PI 3 значительно превосходит обычное Arduino у которого тактовая частота как правило 16 МГц а разрядность микроконтроллера 8 бит, Arduino безусловно занимает своё место в выполнении операций не требующих большой производительности но когда её уже не хватает Raspberry PI "приходит на помощь" и перекрывает такой большой диапазон возможных применений что можно быть абсолютно уверенным в целесообразности приобретения данного одноплатного компьютера Raspberry PI 3 (можно заказать по ссылке) . Т.к. Raspberry PI - это компьютер то для того чтобы его использовать нужно на него установить операционную систему (хотя существуют обходные пути но всё же лучше и проще установить операционную систему (ос далее)). Существует много ос которые можно установить на Raspberry Pi но одной из самых популярных (для использования с Raspberry Pi), наиболее подходящих для начинающих является ос Raspbian. Для того чтобы установить ос на Raspberry Pi понадобиться micro sd карта с расширителем для того чтобы её можно было вставить в обычный компьютер и записать на неё ос. Sd карта должна иметь не менее 4Гб памяти при установке полной версии Raspbian и не менее 8Гб для установки минимальных версий Raspbian. Минимальные версии могут не иметь (и скорее всего не имеют) графического интерфейса и много всего остального что может считаться лишним и занимает место. Для избежания проблем с отсутствием необходимых файлов, можно поставить полную версию. Можно использовать SD карту 10го класса и с 32Гб памяти (проверено работает (как см. видео ниже)). После приобретения карты памяти её надо вставить в компьютер в соответствующий разъём, после этого посмотреть с какой буквой появился диск в разделе "мой компьютер" и запомнить, потом надо скачать ос с официального сайта https://www.raspberrypi.org/downloads/raspbian/ нажав кнопку "Download ZIP" под "RASPBIAN JESSIE" для скачивания полной версии или под "RASPBIAN JESSIE LITE" для скачивания облегчённой но, для начинающих, лучше выбрать "RASPBIAN JESSIE" т.е. полную версию. После скачивания архива "RASPBIAN JESSIE" его нужно разархивировать, потом скачать программу (или от сюда https://yadi.sk/d/SGGe1lMNs69YQ), установить её, открыть, далее нужно в правом верхнем углу указать букву диска (запомненную ранее), найти разархивированный образ ос

И нажать кнопку "write".

После чего выведется окно с предупреждением и в этом окне надо нажать кнопку "Yes",

После того как запись закончиться и появится окно сообщающее об успешной записи (Write Successful) нужно нажать кнопку "Ok" в этом окне.

Потом закрыть программу, вытащить SD карту безопасным способом и вставить в Raspberry Pi.

Далее можно подключить к Raspberry Pi usb клавиатуру (или ps2 через переходник), usb мышь и монитор или телевизор через hdmi кабель или можно подключить ethernet кабель (но это для опытных пользователей поэтому далее рассмотрим первый вариант). После этого надо подключить питание через micro usb например от зарядного устройства от смартфона. После подключения питания начнётся установка операционной системы. Как правило в новых (на момент написания данной статьи) версиях ос уже настроена возможность связи с Raspberry Pi по SSH и поэтому для того чтобы настроить связь с Raspberry Pi 3 по wifi достаточно настроить только wifi, Для этого в правом верхнем углу экрана есть значёк на который нужно нажать и выбрать wifi,

После чего вписать пароль от данного wifi в появившееся текстовое поле,

После этих действий wifi на Raspberry Pi 3 будет настроен и дальше можно будет не используя провода программировать Raspberry Pi 3 удалённо по wifi. После настройки Raspberry Pi 3 можно выключить вписав в командной строке (в программе LXTerminal которую можно открыть двойным кликом по иконке программы) команду sudo halt или нажав соответствующие кнопки выключения в графическом режиме, после окончательного выключения можно отключить питание и при следующей подаче питания Raspberry Pi 3 включиться с wifi. Теперь чтобы программировать Raspberry Pi 3 по wifi нужно выяснить какой у него ip адрес. Для того чтобы это сделать надо подать питание на Raspberry Pi 3, дождаться окончания загрузки ос, зайти в веб интерфейс маршрутизатора (вписав в строке браузера 192.168.1.1 или то что надо для входа в веб интерфейс, ввести логин и пароль), найти вкладку DHCP Leases или что то подобное, найти там строку с raspberry и ip адрес Raspberry Pi 3.

Далее нужно открыть программу PuTTY (если её нет то перед этим скачать (или ) и установить) поставить порт 22, соединение по SSH, вписать в поле "Host Name (or IP Adress)" ip адрес Raspberry Pi 3,

После чего нажать кнопку "Open" внизу окна, далее появиться чёрное окно с предложением ввести логин. По умолчанию логин "pi" - его надо ввести и нажать enter. Далее надо ввести пароль, по умолчанию "raspberry". При вводе пароля он не отображается - это нормально. После того как пароль введён невидимыми буквами нужно нажать enter и если всё было сделано правильно то мы получим доступ к Raspberry Pi 3 если нет то нужно повторить действия. После того как получен доступ к Raspberry Pi 3 можно его программировать, для начала нужно войти в папку "pi" для этого надо вписать команду

И нажать enter (после cd обязательно пробел).
Теперь можно открыть текстовый редактор nano. Nano - это специальный текстовый редактор который есть на большинстве ос на подобии Linux и в котором можно написать программу для Raspberry Pi. Для открытия этого редактора и одновременно с этим создания файла с названием "first" и расширением "py" нужно вписать команду

И нажать enter. Откроется редактор nano и можно заметь что его интерфейс немного отличается но в основном - это то же чёрное поле в которое надо вписывать команды. Т.к. мы хотим управлять портами ввода вывода общего (GPIO) то прежде чем запустить программу по управлению этими портами, нужно подключить к ним какое нибудь устройство чтобы можно было видеть что управление получилось. Надо также отметить что пины настроенные как выходы у Raspberry Pi могут выдавать очень небольшой ток (предполагаю что до 25мА) и учитывая что Raspberry Pi это всё таки не самое дешёвое устройство то настоятельно рекомендуется позаботиться от том чтобы нагрузка на выводы не была слишком большой. Маломощные индикаторные светодиоды, как правило, могут использоваться с Raspberry Pi т.к. им для того чтобы светиться достаточно небольшого тока. Для первого раза можно сделать приспособление с разъёмом, двумя встречно параллельно включёнными светодиодами и резистором с сопротивлением 220Ом включённым последовательно со светодиодами. Т.к. сопротивление резистора 220Ом, ток обязательно проходит через этот резистор и нет параллельных путей его прохода, напряжение на выводах 3.3В то ток не будет больше чем 3.3/220=0.015А=15мА. Подключить это можно к свободным GPIO например к 5 и 13 как на схеме

(распиновка взята с https://en.wikipedia.org/wiki/Raspberry_Pi), выглядеть это может примерно так:

После того как всё аккуратно и правильно подключено и есть уверенность в том что ничего не сгорит можно скопировать в редактор NANO первую простенькую программу на языке Python

Import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(5, GPIO.OUT)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.cleanup()

Потом нажать

После выхода из редактора NANO можно ввести команду

Sudo python first.py

После чего светодиоды помигают некоторое количество раз. Т.е. получилось управлять портами ввода вывода общего назначения по wifi! Теперь давайте рассмотрим программу и выясним как это получилось.
Строка:

Import RPi.GPIO as GPIO

Это подключение библиотеки "GPIO" для управления выводами.
Строка:

Это подключение библиотеки "time" для задержек.
Далее идёт установка режима GPIO:

GPIO.setmode(GPIO.BCM)

Конфигурация выводов 5 и 13 как выходы:

GPIO.setup(13, GPIO.OUT)
GPIO.setup(5, GPIO.OUT)

Установка логической единицы на выводе 13, установка логического нуля на выводе 5:

GPIO.output(13, True)
GPIO.output(5, False)

Задержка

Установка логического нуля на выводе 13, установка логической единицы на выводе 5:

GPIO.output(13, False)
GPIO.output(5, True)

Переводит все выводы в исходное состояние и программа завершается. Т.о. можно управлять любыми свободными пинами по wifi и если сделать питание 5В от аккумулятора то уже можно сделать какого нибудь автономного робота или устройство не привязанное проводами к чему либо стационарному. Язык программирования Python (питон) отличается от си подобных языков, например вместо точки с запятой, для завершения команды, в питоне используется перевод строки, вместо фигурных скобок используется отступ от левого края который делается клавишей Tab. В общем Python это очень интересный язык на котором получается легко читаемый простой код. После того как работа (или игра) с Raspberry PI 3 закончена можно его выключить командой

И после полного выключения убрать питание. При подаче питания Raspberry PI 3 включается и с ним снова можно работать (или играть). Заказать Raspberry pi 3 можно по ссылке http://ali.pub/91xb2 . О том как делается настройка Raspberry PI 3 и управление его пинами можно посмотреть на видео:

После успешного мигания светодиодами можно приступить к полномасштабному изучению данного компьютера и созданию проектов используя возможностями Raspberry PI 3 которые ограничены лишь вашим воображением!

Сегодня четвертый урок, на котором мы поработаем с портами GPIO, в частности помигаем светодиодом в разных режимах.

Урок ориентирован на начинающих пользователей и представлен в текстовом и видео-форматах.

Видео четвертого урока:

Для урока нам понадобится:

плата Raspberry Pi;
кабель питания;
USB-клавиатура;
USB-мышь;
монитор или телевизор с HDMI/RCA/DVI интерфейсом;
кабель, один конец которого RCA или HDMI, а другой соответствует вашему монитору;
SD-карта с уже установленной ОС Raspbian ();
светодиод;
кнопка;
резистор на 220 Ом
3 провода «мама-папа»
2 провода «папа-папа».

Программирование Raspberry Pi GPIO на языке Python

Для сегодняшнего урока мы выбрали язык программирования Python.

Python — современный объектно-ориентированный язык. Он наиболее часто используется для программирования GPIO на Raspberry Pi. Python входит в состав операционной системы Raspbian.

Сборка модели

Для работы нам потребуется собрать следующую схему:

Схема подключения светодиода и кнопки к Raspberry Pi

Обратите внимание, что порты GPIO на Raspberry Pi не подписаны, полезно иметь распечатанную распиновку.

Распиновка Raspberry Pi. Схема с ledgerlabs.us

Собранная модель со светодиодом и кнопкой

Управление светодиодом на Raspberry Pi из консоли

Заходим в LXTerminal и набираем:

После этого вместо имени пользователя в начале строки должно отобразиться >>> .

Вводим следующие строки:

Import RPi.GPIO as GPIO #импорт библиотеки
GPIO.setmode(GPIO.BOARD) #"включение" GPIO
GPIO.setup(7, GPIO.OUT) #объявление 7-го пина как выход

Затем для включения светодиода можно использовать команду
GPIO.output(7, 1)

А для выключения
GPIO(output(7, 0)

После работы с GPIO желательно выполнить команду
GPIO.cleanup()

Программа для мигания светодиодом на Raspberry Pi

Для автономной работы светодиода нам потребуется написать и запустить программу. Для этого откроем предустановленную программу IDLE 3 и в меню File нажмем New. В открывшемся окне мы можем писать программу.

Напишем:
import RPi.GPIO as GPIO #импорт библиотеки для работы с GPIO
import time #импорт библиотеки для ожидания
GPIO.setmode(GPIO.BOARD) #"запуск" GPIO

____GPIO.output(7, 1) #включение светодиода

____GPIO.output(7, 0) #выключение светодиода
____time.sleep(1) #ожидание 1 секунды

Сохраним программу в папке /home/pi.

Теперь мы можем запустить программу из LXTerminal с помощью команды
sudo python programname.py

Управление светодиодом с помощью кнопки

Поуправляем светодиодом с помощью внешней кнопки: когда кнопка зажата — светодиод горит, когда отжата — не горит.

Для этого подключим кнопку к порту 5.

Для управления нам потребуется следующая программа:

Import RPi.GPIO as GPIO #импорт библиотеки GPIO
GPIO.setmode(GPIO.BOARD) #"включение GPIO"
GPIO.setup(7, GPIO.OUT) #объявление порта 7 как выход
GPIO.setup(3, GPIO.IN) #объявление порта 3 как вход
while True: #бесконечный цикл
____if GPIO.input(3) == False: #если кнопка зажата
________GPIO.output(7, 1) #включаем светодиод
____else: #иначе
________GPIO.output(7, 0) #выключаем

Управление светодиодом с клавиатуры

Сделаем еще одну программу. Она будет менять состояние светодиода при получении пустой строки и заканчиваться при получении другой строки.

Import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7, GPIO.OUT)
while True:
____str = input("Enter - включение, другое - выход ");
____if str != "":
________break
____else:
________GPIO.output(7, 1)
____str = input("Enter - выключение, другое - выход ");
____if str != "":
________break
____else:
________GPIO.output(7, 0)
GPIO.cleanup()

На этом четвертый урок по Raspberry Pi для начинающих закончен, продолжение следует!

До сих пор Raspberry Pi остается одним из самых популярных технологических гаджетов.На эту плату Вы можете установить практически любую операционную систему. Но сегодня мы поговорим о том, как писать программы для этой платы без операционной системе, пользуясь лишь аппаратными средствами.

В чем подвох?

На первый взгляд задача кажется тривиальной: скачиваем keil, создаем проект… Но все не так просто. Все среды программирования(keil, IAR, Atolic) поддерживают максимум ARM9.У нас же ARM11. Это связано с негласным правилом, что на голом железе пишут до ARM9, а после на Линуксе. Но все-таки есть одна лазейка: arm-none-eabi-gcc поддерживает любой ARM.
Вторая проблема заключается в том, что под данный процессор(BCM2835) нет никаких конфигурационных файлов, header"ов и т.д. Здесь нам на помощь придет загрузчик Raspberry Pi. И ничего, что он пропритетарный. Он выполняет две функции: инициализирует процессор и его периферию, а также передает управление ядру kernel.img. Мы просто замаскируем свою программу под ядро и загрузчик её запустит.

Что нам понадобится?

1) Сама Raspberry Pi, карта памяти к ней и питание.
2) Даташит на процессор
3) Компьютер с установленным Linux (но может быть можно и на Винде. Не знаю, не пробовал).
4) Кросскомпилятор, установленный на компьютере из пункта 3. Я использую arm-none-eabi-gcc
5) Содержимое этой папочки.

Приготовления.

Нам нужно отформатировать карту памяти в FAT16 и закинуть на нее содержимое этой папки . Это загрузчик плюс ядро. Затем удаляем оттуда файлы kernel.img и kernel_emergency.img. Это ядро Linux, а оно нам не нужно.

Первая программа.

Теперь мы можем приступить к написанию первой программы. Создаем файл main.c и пишем следующий код
int main (void) { while(1) { } } void exit (void) { while(1) { } }
Как видите, эта программа ничего не делает. Функция exit зачем-то нужна компилятору.
Теперь соберем её.

arm-none-eabi-gcc -O2 -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s -nostartfiles main.c -o kernel.elf
arm-none-eabi-objcopy kernel.elf -O binary kernel.img

Полученный файл kernel.img кидаем на карту памяти. Готово!

GPIO

Вряд ли Вас устроит программа, которая не будет делать абсолютно ничего. Сейчас попробуем зажечь лампочку.
Для начала объявим адрес, по которому лежит GPIO(это можно прочитать в даташите).

#define GPIO_BASE 0x20200000UL

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

#define GPIO_GPFSEL1 1
#define GPIO_GPCLR0 10

Ну и наконец модифицируем главную функцию для зажигания лампочки:
volatile unsigned int* gpio; int main(void) { gpio = (unsigned int*)GPIO_BASE; gpio |= (1 << 16); gpio = (1 << 16); while(1) { } }

Собираем, прошиваем и радуемся.

В следующей части попробуем поиграться с таймерами и прерываниями.

Raspberry Pi – мощная платформа для обработки информации, полученных от разнообразных устройств. Этот микрокомпьютер может стать основой для создания систем умного дома и устройств распознавания образов. Наиболее удобной и популярной средой программирования для Raspbian является Питон. В это статье мы узнаем, как настроить Python на Raspberry Pi и как установить библиотеку RPI.GPIO для работы с GPIO портами.

Установка и настройка Python на Raspbian

Python – один из самых известных и используемых языков программирования. Изначально язык Python должен был выступать в роли основного языка программирования для Raspberry Pi. В микрокомпьютере Raspberry Pi он используется для работы с датчиками через GPIO при помощи специальной библиотеки. Пакет Python уже установлен в операционной системе Raspbian в двух версиях – 2 и 3. Каждый элемент в системе Raspbian перед именем имеют приставку «python-».

Установка и инсталляция пакетов выполняются с помощью утилиты apt либо pip.

Установить пакет утилитой apt можно при помощи команд:

sudo apt-get update

sudo apt-get install python3-picamera

Это один из лучших методов установки программного обеспечения. Благодаря такой установке программы можно легко обновить до последней версии – для этого используются команды sudo apt-get update и sudo apt-get upgrade.

Удалить ненужные элементы можно, запустив команду sudo apt-get remove python3-rpi.gpio.

Полное удаление можно произвести, добавив к команде окончание –purge:

sudo apt-get remove python3-rpi.gpio –purge.

Установка пакетов через PIP. Этот инструмент нужно тогда, когда невозможно найти нужный пакет или его последнюю версию. В это случае установка проводится через PyPI – каталог пакетов Python. Установка так же не вызывает трудностей, как и в предыдущем случае. Сначала нужно установить пакет через apt:

sudo apt-get install python3-pip (на примере третьей версии)

Команда pip-3.2 устанавливает нужные документы и файлы для python. Например, установить любую библиотеку можно следующим образом:

pip-3.2 install library

Удалить – с помощью команды

pip-3.2 uninstall.

Сам язык программирования Python характеризуется простым синтексом и высокой функциональностью, поддерживает автоматическое управление памятью, многопоточность вычислений, обработку исключений. Для этого языка существует большое количество библиотек для самых разнообразных сфер применения. Существуют расширения для создания игр – Pygame, для работы с мультимедиа, обработки графики, различных вычислений.

Установка библиотеки RPi.GPIO

Библиотека RPi.GPIO написана специально для управления портами GPIO на языке python. Эти порты позволяют собирать данных с датчиков, управлять двигателями, ключами, реле и прочими устройствами с помощью программы.

В первую очередь нужно скачать архив с официального сайта . На странице можно увидеть большое количество версий библиотеки. Нужно выбрать самую свежую версию.

Архив будет загружен в папку загрузки по адресу /home/pi/Downloads. Нужно зайти в нее, найти скачанный архив, нажать правую кнопку мыши и выбрать во всплывающем меню Extract Here.

Эта команда разархивирует библиотеку в папку, в которую помещен архив. Рядом с ним будет добавлена новая папка с названием RPi.GPIO-0.6.3.

Следующим шагом нужно установить python-dev. Запускается терминал и в него вводится команда

sudo apt-get install python-dev

Будет задан вопрос «Do you want to continue? », нужно нажать «Yes» и Enter.

В окне высветится отчет, который сообщает об успешно проведенной установке.

Чтобы установить библиотеку RPi.GPIO, нужно не закрывая перейти в папку, которая была распакована до этого.

cd /home/pi/Downloads/RPi.GPIO-0.6.3

Затем нужно запустить команду:

python setup.py build

На экране появится отчет о выполнении.

После этого нужно запустить установку библиотеки с помощью команды

sudo python setup.py install

После успешной установки на экране появится новый отчет.

Библиотека установлена, можно начинать работать.

Помимо вышеописанной библиотеки RPi.GPIO существуют и другие. Для доступа к GPIO контактам используется также библиотека WiringPi. Эта библиотека написана на языке C, используется в средах C, C++ и RTB (BASIC) и других. Она создавалась схожей с библиотекой Wiring на Ардуино.

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

Что делать, когда нечего делать?
Попробовать что-нибудь новое!

Если вы приобрели Raspberry Pi просто ради любопытства, не отдавая себе отчёта в том, для чего он конкретно вам нужен, то наверняка с каждым днём вам становится всё труднее найти для него
применение. Вы уже с ним вдоволь наигрались. Попробовали установку разных операционных систем, послушали музыку, посмотрели видео, попробовали поиграть и порисовать… И наверняка с огорчением для себя сделали вывод - «Всё ж таки Raspberry Pi мало годится для использования в качестве настольного компьютера». Слишком он уж медленный и задумчивый, по сравнению с обычным компьютером. И вроде бы ничего серьезного с ним сделать нельзя. Остаётся лишь найти ему применение в качестве либо медиацентра, либо простенького интернет-сервера, который не страшно
оставлять включённым круглые сутки…
Но всё ж таки Raspberry Pi может делать одну вещь гораздо более эффективнее, чем любой домашний компьютер- он может управлять внешними устройствами. Устройства могут быть абсолютно любыми, от обычной лампочки, до беспилотного летательного аппарата. В данном случае, область применения Raspberry ограничена лишь вашей фантазией и знаниями. И если вы никогда и ничего подобного не делали, но это вас заинтересовало, то эта статья для вас. И так, начнём.
Чтобы общаться с любыми внешними устройствами и управлять ими, Raspberry Pi имеет на борту интерфейс, называемый GPIO . Это аббревиатура от General Purpose Input Output . А по-русски, это низкоуровневый интерфейс ввода-вывода прямого управления. На плате Raspberry он находится в углу, в виде гребёнки из 26 штырьков, рядом с видеовыходом. Т.е.
через этот интерфейс Raspberry может слушать и отдавать команды любому внешнему устройству, например беспилотнику. Но сегодня мы беспилотник строить не будем, начнём с обычной лампочки, а точнее светодиода, который и исполнит роль подопытной лампочки. Наша задача- заставить светодиод, подключённый к Raspberry включаться и выключаться по его команде. Кроме того, дабы убедиться, что эти включения происходят вполне осознано и так, как мы этого хотим, а не благодаря каким-то глюкам в недрах процессора, мы привнесём в нашу программу элемент
общения с нами. Т.е. отстроим чёткую иерархию- Raspberry управляет светодиодом,
а самим Raspberry управляем мы. Теперь надо подготовиться и раздобыть где-то
несколько вещей. Во-первых, нужно найти светодиод :

Его можно достать из старой сломанной игрушки, из зажигалки с фонариком, попросить у знакомого радиоэлектронщика, в конце концов, просто купить.
Во-вторых, понадобятся проводочки любые и парочка коннекторов BLS :

Такие коннекторы можно вытащить из старого системного блока вместе с проводами, или попросить у знакомого компьютерщика, или тоже купить. Они прекрасно подходят для подключения к разъёму на Raspberry. Начнём с планирования используемых портов. Порт- это грубо говоря штырёк на разъёме. Так, как штырьков там много (26), то и портов тоже много. А чтобы в них не
запутаться, то каждому порту присвоен свой номер и обозначение. Следует заметить, что не все штырьки в этом разъёме являются портами. Некоторые штырьки
подключены к источникам напряжения, а некоторые вообще никуда не подключены (По секрету, на самом деле они всё-же подключены, но ими пользоваться нельзя, можно
убить свою Малинку. Поэтому лучше вобще их не трогайте).
Вот собственно как
эти порты расположены на плате:

Чтобы светодиод зажёгся, нам нужно его подключить к источнику питания. Выбираем для питания светодиода Р1-01 , верхний по рисунку штырёк, на котором присутствует
напряжение 3,3в. Для управления светодиодом нам понадобится один порт GPIO. Можно выбрать любой. Но если у вас есть разъём BLS, то удобнее в данном случае использовать порт, который выведен на штырёк P1-03 и называется GPIO 0 . В таком случае мы, воспользовавшись одним разъёмом, сможем подключить наш светодиод. И так, мы будем подключать светодиод между ножками разъёма P1-01 и Р1-03 . С вывода Р1-01 мы берём +3,3в для питания светодиода, а вывод Р1-03 будет тем самым управляющим выводом порта GPIO. Все эти порты физически находятся внутри центрального процессора Raspberry Pi, который называется BCM2835. Этот процессор может подключать любой порт к источнику напряжения 3,3в, а может подключить порт к 0 питания (а может вообще никуда не подключать, но об этом позже). Эти переключения он делает в соответствии с поданной командой. Значит, когда порт будет подключён к напряжению +3,3в, наш светодиод гореть не будет, т.к. току некуда идти. А когда процессор подключит порт к 0, то наш светодиод загорится, т.к. ток побежит от +3,3в к 0 через светодиод. Значит наша программа должна будет отдавать соответствующие команды процессору в соответствии с нашим желанием.
Маленькое, но важное
отступление. На самом деле, мы не должны подключать светодиод напрямую между источником питания +3,3в и выводом порта. Это нельзя делать по двум причинам. Причина первая: любой светодиод нормально работает при определённом токе. Если через светодиод потечёт большой ток (а выход +3,3в способен отдать до 50мА), то светодиод сгорит. Если маленький ток, то светодиод будет гореть слишком слабо, либо вообще не будет светиться. Для большинства обычных светодиодов рабочий ток находится в пределах 10-20мА. Отсюда вытекает и вторая причина (хотя в данном случае она несущественна). Если мы пропустим большой ток через порт GPIO, то этим самым мы уничтожим процессор и Raspberry- умрёт. Поэтому, мы должны следить, чтобы через порт не протекал ток больше допустимого. Примем для себя ограничение в 16мА, так мы точно не сожжем процессор. Как этого добиться? Очень просто! Нам нужно последовательно со светодиодом
включить токоограничивающий резистор. И сейчас мы его рассчитаем.
Примем для светодиода рабочий ток в 10мА. Убеждаемся в том, что выбранный нами ток не превышает предельно допустимый ток для порта в 16мА. Теперь зная напряжение питания 3,3в и рабочий ток 10мА, мы можем по закону Ома рассчитать необходимое нам сопротивление. R=U/I=3,3/0,01=330Ом . Значит нам нужно найти резистор с сопротивлением 330Ом. А точнее- сопротивлением не менее 330Ом. Больше- можно. Светодиод будет заметно светиться и при сопротивлении 1000 Ом, или 1кОм. В общем наша задача- найти резистор с
сопротивлением от 330 Ом до 1кОм. Если вы его нашли, то можно собрать вот такую схему:

Схему лучше собрать на макетной плате. Лично мне, для экспериментов, мой сын дал на прокат свой конструктор «Знаток».
Так выглядит схема в сборе:

Так мы подключаемся к Raspberry:

А вот общий план всей конструкции:

В крайнем случае, можно просто скрутить выводы элементов. Но в этом случае нужно следить за тем, чтобы оголённые ножки элементов случайно не попали на контактные площадки Raspberry. Это может убить его. Так же стоит обратить внимание на то, что светодиод должен подключаться Анодом к + источника питания, т.е. в нашем случае это Р1-01 . Как найти на светодиоде Анод? Очень просто! Достаньте из любого ДУ батарейку на 1,5В и подключите к ней ваш светодиод. Если он не зажёгся, поменяйте выводы местами. Если зажёгся- то на + батарейки и будет Анод светодиода.

Если вы собрали схему, то отложите пока её в сторонку. Теперь мы займёмся второй частью задачи - написанием программы управления светодиодом. Писать эту программу мы будем на языке Си.
Почему на именно на Си? Просто по тому, что я других языков не знаю, а раз вы читаете эту статью, то скорее всего вы тоже немного знаете о программировании и радиоэлектронике, а значит, вам всё равно с какого языка начинать.
Обычно изучение языков программирования начинают с написания программы «Hello World!», но мы же круче «тех» чайников, поэтому мы начнём сразу с низкоуровневой работы с периферией. Тем более, что это не намного сложнее ХеллоуВорлда. ;) Что для этого нужно? Нужен любой текстовый редактор, в котором мы будем набирать программу. В Raspbian есть отлично подходящий для этого редактор “nano ”. Ещё нужен компилятор, это программа, которая осуществляет перевод написанной нами программы с человечески понятного языка на язык, понятный компьютеру. Т.е. делает из нашей программы исполняемый файл, который мы впоследствии и запустим на Raspberry. Эта штука тоже у нас есть, называется gcc . Этот компилятор поставляется в комплекте со всеми Линуксами и уже готов к работе.
Как видите,всё необходимое у нас уже есть. Хотя нет. Одной вещи все-таки у нас не хватает. Её мы возьмем из интернета. Речь идёт о библиотеке функций управления портами GPIO на Raspberry, специально написанно добрым человеком для того, чтобы наша программа по своей простоте могла бы соперничать с «Хеллоуворлдом» и нам самим бы не пришлось ломать голову, изучая техническую документацию на процессор и протоколы работы с его внутренностями. Сама библиотека состоит из заголовочного файла, в котором обозначены все имена функций со структурами переменных и файла библиотеки самих функций. Эту библиотеку нужно скачать и установить, чтобы компилятор мог с ней работать. Библиотека называется bcm2835-1.17 . Последние цифры в названии библиотеки, обозначают её версию. А так, как библиотека постоянно обновляется автором, то версии будут меняться. на сегодняшний день доступна версия 1.17. Узнать о номере последней версии можно по адресу: http://www.open.com.au/mikem/bcm2835/index.html По этой же ссылке вы можете ознакомиться со всеми функциями, которые присутствуют в этой библиотеке.
Мы же пока установим версию 1.17. Запускаем окно терминала и вводим
туда команду:
wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.17.tar.gz Библиотека быстренько скачивается. Чтобы её установить, нужно сначала её разархивировать. Это делается следующей командой:
tar zxvf bcm2835-1.17.tar.gz
Теперь перейдём в директорию, куда эта библиотека развернулась:
cd bcm2835-1.17
Ну и инсталлируем её:
./configure make
sudo make check
sudo make install
Всё, теперь эта библиотека у нас есть в наличии, она установлена, и мы, и компилятор можем ей пользоваться в своих интересах. Начинаем писать программу. Возвращаемся в домашнюю директорию:cd ..
Тут можно создать папочку для наших экспериментов с любым именем, например myprog:
mkdir myprog
Перейдём в эту папку:
cd myprog И начинаем писать нашу программу:nanoGPIO-test.c
Эта команда запускает текстовый редактор nano , который создаёт текстовый файл GPIO-test.c .Теперь можете набрать в нём следующую программу
(можно просто скопировать и вставить):

//GPIO-test.c
// Программа включает на 1 секунду светодиод,
// подключённый к порту Р1_03
// Компиляция командой gcc -o GPIO-test GPIO-test.c -lrt -lbcm2835

#include

#define PIN RPI_GPIO_P1_03 // Для RPi ревизии v1
//#define PIN RPI_V2_GPIO_P1_03 // Для RPi ревизии v2

Int main()
{
if (!bcm2835_init()) // Инициализация GPIO
return 1; //Завершение программы, если инициализация не удалась

Bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP); //Устанавливаем порт Р1_03 на вывод
bcm2835_gpio_write(PIN, LOW); // Устанавливаем порт в 0, светодиод горит
bcm2835_delay(1000); // Ждём 1000 милисекунд
bcm2835_gpio_write(PIN, HIGH); // Устанавливаем порт в 1, светодиод не горит
return 0; // Выход из программы
}

Обратите внимание на строки #define. Их в программе 2 и одна из них закомментирована. Одна строка для ревизии RPi v1, вторая для RPi v2.
Если у вас v1, то всё оставьте как есть. Если у вас RPi v2, то первую строку с #define удалите, а со второй уберите символ комментария //. В будущем, во всех остальных программах, просто добавляйте _V2_ между RPI и GPIO в определении портов, если ваша плата RPi v2.
Сохраняем нашу программу ctrl-o и выходим из текстового редактора ctrl-x . Теперь, если вы введёте команду ls , то увидите только что созданный файл GPIO-test.c. Чтобы этот файл превратился в работающую программу, его нужно скомпилировать. Пишем: gcc -o GPIO-test GPIO-test.c -lrt -lbcm2835 в этой строке: gcc- это имя компилятора; -o GPIO-test GPIO-test.c эта команда компилятору говорит о том, что требуется создать исполняемый файл с именем GPIO-test из текстового файла GPIO-test.c; -l (латинская л маленькая) bcm2835 говорит компилятору о том, что все неизвестные ему функции в нашей программе, он может найти в установленной библиотеке bcm2835. Если компилятор не выдал никаких сообщений, то значит, всё у нас получилось. Если сейчас дать команду ls , то мы увидим, что в директории появился ещё один файл GPIO-test, причём он отмечен зелёным цветом. Это говорит о том, что файл является
исполняемой программой. Осталось нам его запустить, но перед этим ещё раз проверяем нашу схему со светодиодом, чтобы всё было собрано правильно и подключено к контактам Р1_01 и Р1_03 разъёма GPIO. Если ошибок не обнаружено, запускаем программу: sudo ./GPIO-test После этого светодиод должен загореться
ровно на 1 секунду и погаснуть. Если всё так и произошло, то я вас поздравляю! Вы только что при помощи Raspberry Pi передали через порт GPIO команды светодиоду: включиться, гореть 1 секунду и выключиться.
Теперь о том, что делает каждая строка в нашей программе.
Все надписи после двойного слеша // являются коментариями и никак не влияют на выполнение программы.

#include -эта строка говорит компилятору, что в программе используется заголовочный файл bcm2835.h. В этом файле находятся все описания функций и идентификаторы портов GPIO.

>#define PIN RPI_GPIO_P1_03 - здесь мы говорим компилятору, что везде в программе, где он увидит идентификатор PIN, ему нужно выполнить замену его на идентификатор RPI_GPIO_P1_03 . Это сделано для того, чтобы мы могли при желании быстро изменить номер подключаемого порта. Для этого достаточно изменить только эту строку, а не выискивать по всей программе, где мы этот идентификатор использовали.

int main() это начало нашей программы, обозначение главной функции в Си.

if (!bcm2835_init()) - эта часть пытается инициализировать GPIO и если это не получилось,
return 1; то аварийно завершает программу и передаёт на выходе код 1.

bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP); - Эта функция устанавливает для нашего порта Р1_03 режим на вывод. Т.е. говорит процессору, что этот порт будет использован для управления внешним устройством.
bcm2835_gpio_write(PIN, LOW); - устанавливаем порт Р1_03 в низкое состояние, т.е. процессор его подключает к 0. После этого светодиод загорается.

bcm2835_delay(1000); - Эта функция просто ждёт 1000 милисекунд, или ровно 1 секунду. Всё это время у нас горит светодиод.

bcm2835_gpio_write(PIN, HIGH); - устанавливаем порт Р1_03 в высокое состояние, т.е. процессор его подключает к +3,3в. При этом светодиод гаснет.

B>return 0; - Выход из программы с кодом 0.

Т.е. алгоритм работы с портом GPIO в режиме записи, т.е. вывода, выглядит следующим образом:
1. Инициализируем GPIO;2. Устанавливаем режим для выбранного порта на Вывод;
3. Теперь можем управлять этим портом, устанавливая его в высокое, или низкое состояние. Соответственно на этом порте будет пристутствовать либо +3,3В, либо 0В. Что соответствует логической 1 и логическому 0 соответственно.

На этом на сегодня закончим. В следующей части научим наш светодиод загораться более полезным образом, а так же научимся портами GPIO не только отдавать команды другим устройством, но и слушать их.А пока можете начинать изучать язык Си. А так же попробуйте изменить эту программу так, чтобы светдиод управлялся бы другим портом и испытайте её.