Remote gpio raspberry что это

Raspberry Pi для домашней автоматизации. Установка Webiopi

В прошлом обзоре мы разобрались, как установить на Raspberry Pi операционную систему Raspbian, выполнить её основные настройки и включить возможность удаленного управления с помощью программы Putty. А сегодня попробуем поработать с внешним интерфейсом нашего миникомпьютера.

Raspberry Pi имеет довольно неплохой набор портов GPIO, которые можно задействовать как аналоговые или цифровые входы/выходы, интерфейсы UART , SPI , I 2 C . В начале рассмотрим использование портов в качестве цифровых выходов и входов.

Для этого воспользуемся готовым фреймворком WebIOPi . Он был специально разработан для работы с портами GPIO Raspberry Pi и позволяет создавать на своей основе различные пользовательские приложения. Как заявлено на официальном сайте поддержки этого проекта http s ://code.google.com/p/webiopi, WebIOPi имеет следующие возможности:

Встроенный Web — c ервер, реализованный на языке Python

Встроенная поддержка более чем 30 устройств с интерфейсами UART , SPI , I 2 C , 1- Wire

Библиотеки Javascript / HTML для создания Web -интерфейса

Библиотеки Python / Java для создания приложений под Android

Совместимость с языком Python версий 2 и 3

Возможность адаптации под нужды пользователей

Структура фреймворка WebIOPi приведена на рис.1:

Рис. 1

Чтобы выполнить установку WebIOPi , заходим в Raspberry Pi через программу Putty (логин – pi , пароль — raspberry ) и в терминале вводим поочередно следующие команды:

$ wget http://sourceforge.net/projects/webiopi/files/WebIOPi-0.7.1.tar.gz

$ tar xvzf WebIOPi-0.7.1.tar.gz

$ cd WebIOPi-0.7.1

$ sudo ./setup.sh

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

$ sudo update-rc.d webiopi defaults

После чего перезапускаем Raspberry Pi :

sudo reboot

Теперь проверяем работу WebIOPi . С любого компьютера в локальной сети набираем сетевой адрес, присвоенный Raspberry Pi с указанием порта 8000. Например:

http ://192.168.1.8:8000

Для доступа к WebIOPi необходимо в открывшейся форме ввести логин и пароль. По умолчанию логин « webiopi », пароль – « raspberry ». Их, как и номер порта, затем можно будет изменить, но об этом поговорим отдельно, а для наших экспериментов воспользуемся стандартными параметрами.

Итак, если вы все сделали правильно при установке WebIOPi , ввели верный логин и пароль, то в браузере должна открыться страница (рис.2)

Рис. 2

На этой странице есть четыре пункта меню. GPIO Header и GPIO List открывают два варианта графических интерфейсов работы с портами ввода/вывода, Serial Monitor – терминал для работы с последовательным портом UART , Devise Monitor – подключенные к GPIO датчики.

Выбираем в меню пункт GPIO Header и попадаем на страницу с графическим интерфейсом управления портами (рис.3)

Рис. 3

Как видно из приведенного рисунка, графический интерфейс представляет собой мнемоническую интерактивную схему портов GPIO Raspberry Pi . По умолчанию, все они настроены как входы ( IN ) . Для использования порта как выхода, нужно кликнуть по IN мышкой и надпись измениться на OUT .

Черный цвет порта указывает, что на выходе низкий уровень (0В), желтый – высокий уровень (3,3В). Для изменения состояния определенного порта кликнем по нему мышкой и уровень на его выходе изменится на инверсный.

Для работы с WebIOPi через Web -интерфейс, рекомендуется использовать браузер Chrome , с другими браузерами корректная работа фреймворка не гарантируется. Однако, я проверял его работу в Opera , Internet Explorer под Windows , Safari под iOS и особых проблем не наблюдалось. Но, тем не менее, лучше все же воспользоваться рекомендацией разработчика и во избежание дополнительных проблем на начальном этапе пользоваться только Chrome .

Как уже отмечалось, при включении все порты GPIO в Raspberry Pi настраиваются как входы. Но, допустим, требуется, что бы при включении определенные порты не только были выходами по умолчанию, но и имели, в случае необходимости, высокий или низкий «стартовый» уровень. Никаких проблем, это довольно просто реализовать в WebIOPi . Остановимся на этом вопросе более подробно.

Подключаемся к Raspberry Pi через терминальную программу Putty (логин – pi , пароль — raspberry ) и открываем для редактирования конфигурационный файл config :

sudo nano / etc / webiopi / config

Допустим, мы хотим что бы порты GPIO 2, 3, 4, 17 были сконфигурированы как выходы с низким стартовым уровнем, порты GPIO 9, 10, 11, 22, 27 – как выходы с высоким стартовым уровнем, а оставшиеся GPIO 7, 8, 18, 23, 24, 25 как входы . Находим в открывшемся конфигурационном файле заголовок:

[ GPIO ] # Initialize following GPIOs with given function and optional value # This is used during WebIOPi start process

Редактируем в соответствии с нашими требованиями (рис.4)

Рис. 4

Надеюсь, что здесь все понятно и без комментариев: IN – это вход, OUT 1 – выход с высоким уровнем, OUT 0 – выход с низким уровнем. Назначение входов IN можно не прописывать – не назначенные в конфигурационном файле порты по умолчанию будут входами.

Сохраняем настройки сочетанием клавиш Ctrl и O , затем нажимаем Enter . Настройки сохранены, делаем перезагрузку Raspberry Pi командой sudo reboot и после перезагрузки заходим на страницу WebIOPi , как это описывалось выше. Мы увидим, что назначение портов GPIO изменилось в соответствии с заданными настройками в конфигурационном файле (рис.5)

Рис. 5

В принципе, даже с помощью рассмотренного «базового» варианта WebIOPi , уже можно организовать систему удаленного управления нагрузками через локальную сеть или интернет. Для этого необходимо подключить к портам GPIO Raspberry Pi транзисторные ключи с электромагнитными реле или симисторы. Однако, нужно предусмотреть некоторые меры предосторожности во избежание выхода из строя портов GPIO . Рекомендуется сделать гальваническую развязку портов входов и выходов, например, через оптроны. Кстати, входы можно задействовать для организации сигнализации переключения исполнительного устройства.

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

По теме удаленного управления нагрузками через GSM рекомендуется почитать:

Устройство управления и контроля по GSM

Управление нагрузками по телефону

Управление нагрузками по радио

Категория: | Просмотров: 40006 | Добавил: Admin | Теги: Raspberry Pi | Рейтинг: 5.0/1 |
Всего комментариев: 13

Руководство по GPIO для начинающих

В этой статье вы узнаете все о контактах GPIO на Raspberry Pi. Этот пост предназначен специально для новичков в электронике.

Прежде всего, предупреждение:

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

Что такое контакты GPIO

Штырьки GPIO — это 40 маленьких металлических штырьков на верхней части Raspberry Pi. Аббревиатура GPIO означает «ввод-вывод общего назначения». Это означает, что контакты GPIO можно использовать в качестве интерфейса практически для любого электронного устройства.

Из-за большого количества способов (неправильного) использования пинов, начало работы может быть немного запутанным. Поэтому в этом блоге приведены примеры управления пинами с помощью Bash, C и Python. Поэтому небольшой опыт в программировании будет преимуществом.

Хотя 40 контактов выглядят одинаково, они имеют разные функции. 26 выводов могут использоваться для GPIO, а некоторые имеют дополнительные функции. Еще 4 вывода используются как источник питания (POWER, два раза 3V3 и два раза 5V), а 8 — как отрицательный полюс (также земля или GROUND). Два оставшихся вывода — это интерфейс I2C для ID EEPROM.

Распиновка

На графике ниже показана самая важная информация, в том числе распиновка. Распиновка идентична для большинства моделей Raspberry Pi, но есть и различия. Всегда проверяйте точную распиновку вашей модели перед подключением устройства. Для этого достаточно открыть терминал на вашем Raspberry Pi (Ctrl+Alt+t) и выполнить следующую команду.

pinout

Вы увидите график всех соединений и точную распиновку вашего Raspberry Pi.

Возможно, вы заметили, что номера GPIO появляются случайно и не совпадают с нумерацией выводов. Чтобы избежать путаницы, я называю номера от 1 до 40 номерами BOARD, а номера от 1 до 26 — номерами BCM или GPIO.

Итак, контакт 1 платы — это разъем 3V3 POWER, а контакт 2 GPIO — это контакт рядом с ним с номером 3 платы.

Как подключить устройство к контактам

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

Смотреть наше видео о контактах GPIO!

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

Bash

Управлять контактами GPIO через Bash очень просто. В Linux пины GPIO управляются файлами в папке /sys/class/gpio папку. Чтобы использовать вывод GPIO, его необходимо сначала экспортировать. В качестве примера я использую вывод GPIO 13. Ниже имена файлов выделены жирным и курсивом.

Откройте терминал и перечислите содержимое папки gpio.

cd /sys/class/gpio ls

Папка содержит файлы export и unexport, а также вложенные папки для каждого экспортируемого пина GPIO.

Мы экспортируем пин, записав номер GPIO в поле /sys/class/gpio/export файл. Выполните эту команду в терминале.

echo 13 > /sys/class/gpio/export ls

Теперь создана папка с соответствующим номером вывода gpio13. Эта папка содержит другие папки и файлы. На данный момент для нас важны только файлы направлений и значений.

Сайт направление файл сохраняет режим работы пина:

в -> Контакт находится в режиме чтения или ввода

на -> Контакт находится в режиме записи или вывода

Сайт значение файл хранит состояние напряжения на выводе:

0 -> вывод находится в режиме НИЗКОГО уровня -> на вывод не подается напряжение

1 -> Контакт находится в режиме HIGH -> На контакт подается напряжение

Следующие команды устанавливают режим на и значение для 1.

echo out > /sys/class/gpio/gpio13/direction echo 1 > /sys/class/gpio/gpio13/value

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

echo 0 > /sys/class/gpio/gpio13/value echo in > /sys/class/gpio/gpio13/direction echo 13 > /sys/class/gpio/unexport

Программа Python

Теперь мы абстрагируемся и автоматизируем эти команды Bash в Python.

Следующий сценарий Python предоставляет простой GPIO_Pin класс. Это делает его чрезвычайно простым в использовании. Сайт os модуль позволяет нам выполнять те же команды bash, что и выше, из Python. также, используя __del__ метод, нам больше не нужно вручную сбрасывать и разворачивать контакты.

import os from time import sleep class GPIO_Pin: def __init__(self, num, mode): if 0  num or num  self.num = num else: print('Invalid Pin Number -> Enter a number from 0 - 40') if mode == 'out' or mode == 'write': self.mode = 'out' elif mode == 'in' or mode == 'read': self.mode = 'in' else: print('Invalid Pin Mode -> Enter "out" or "write" for output, "in" or "read" for input') if self.num and self.mode: os.system(f'echo > /sys/class/gpio/export') sleep(0.05) os.system(f'echo > /sys/class/gpio/gpio/direction') def reset(self): os.system(f'echo 0 > /sys/class/gpio/gpio/value') os.system(f'echo in > /sys/class/gpio/gpio/direction') def write(self, value): if value == 0 or value == 'LOW': os.system(f'echo 0 > /sys/class/gpio/gpio/value') elif value == 1 or value == 'HIGH': os.system(f'echo 1 > /sys/class/gpio/gpio/value') else: print('Invalid value -> Enter 1 or "HIGH" for HIGH, 0 or "LOW" for LOW') def __del__(self): self.reset() os.system(f'echo > /sys/class/gpio/unexport') def set_mode(self, mode): self.mode = mode os.system(f'echo > /sys/class/gpio/gpio/direction') def main(): pin = GPIO_Pin(13, 'out') number_of_blinks = 10 for i in range(number_of_blinks): pin.write('HIGH') sleep(0.5) pin.write('LOW') sleep(0.5) if __name__ == '__main__': main()

С помощью модуля времени мы можем даже заставить светодиод мигать без каких-либо проблем. Весь сценарий может быть расширен до модуля Python для управления GPIO.

Программа C

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

gcc -o gpio gpio.c ./gpio

#include stdio.h> #include stdlib.h> #include unistd.h> #define GPIO_ROOT "/sys/class/gpio" #define EXPORT "/sys/class/gpio/export" #define UNEXPORT "/sys/class/gpio/export" #define LOW 0 #define HIGH 1 int export_pin(int num)  FILE* export = fopen(EXPORT, "w"); if (export == NULL)  printf("Failed to open the export file\n"); exit(-1); > fprintf(export, "%d", num); fclose(export); return 0; > int unexport_pin(int num)  FILE* unexport = fopen(UNEXPORT, "w"); if (unexport == NULL)  printf("Failed to open the unexport file\n"); exit(-1); > fprintf(unexport, "%d", num); fclose(unexport); return 0; > int set_direction(char *mode, int num)  char direction_file_path[1024]; snprintf(direction_file_path, sizeof(direction_file_path), "/sys/class/gpio/gpio%d/direction", num); FILE* direction = fopen(direction_file_path, "w"); if (direction == NULL)  printf("Failed to open the direction file\n"); exit(-1); > fputs(mode, direction); fclose(direction); return 0; > int set_value(int val, int num)  char value_file_path[1024]; snprintf(value_file_path, sizeof(value_file_path), "/sys/class/gpio/gpio%d/value", num); FILE* value = fopen(value_file_path, "w"); if (value == NULL)  printf("Failed to open the value file\n"); exit(-1); > fprintf(value, "%d", val); fclose(value); return 0; > int main()  int rslt; int num; int num_blinks; num = 13; num_blinks = 10; rslt = export_pin(num); rslt = set_direction("out", num); for (int i = 0; i  num_blinks; i++)  rslt = set_value(HIGH, num); sleep(1); rslt = set_value(LOW, num); sleep(1); > rslt = set_value(LOW, num); rslt = set_direction("in", num); rslt = unexport_pin(num); return EXIT_SUCCESS; >

PiCockpit — приложение для работы с GPIO

Самый простой способ управления контактами GPIO — с помощью приложения GPIO. На сайте Веб-интерфейс PiCockpit бесплатно для 5 Raspberry Pi. Он предлагает два больших преимущества: Вам не нужно знать программирование, чтобы управлять контактами GPIO, и вы можете делать это из любого места.

Просто установите клиент PiCockpit на свой Raspberry Pi и подключитесь к своей учетной записи PiCockpit. После этого вы сможете легко управлять пинами GPIO через веб-интерфейс.

Следующие шаги

Теперь вы знаете, как использовать контакты GPIO с помощью проводов-перемычек. Конечно, существуют также внешние модули Python и библиотеки C для управления контактами GPIO. Хорошим следующим шагом будет расширение одного из примеров кода. Например, с помощью дополнительных светодиодов или кнопки.

GPIO для чайников (часть 1)

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

Если вы приобрели 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 не только отдавать команды другим устройством, но и слушать их.А пока можете начинать изучать язык Си. А так же попробуйте изменить эту программу так, чтобы светдиод управлялся бы другим портом и испытайте её.

Веб-контроль Raspberry Pi GPIO

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

• Серверная программа, которая работает на Raspberry Pi, для того чтобы читать переменные
• Базы данных MySQL для хранения переменных
• Веб-страница Apache2, для того чтобы контролировать переменные

Шаг 1. База знаний

• Веб-сервер Apache
• PHP5
• Сервер MySQL
• phpMyAdmin

Если хотите узнать, как всё это настроить, вам сюда (инструкция на английском языке).

Шаг 2. Создание root аккаунта

Пропустите это, если у вас уже есть аккаунт, а если нет — продолжайте прочтение 🙂

Войдите в Raspberry Pi используя следующую команду:
sudo -i
passwd root

Теперь введите и подтвердите пароль для учётной записи.
Затем нужно закрыть SSH сессии и перезапустить его, войдя в систему как root.

Шаг 3. Настройка баз данных и phpMyAdmin

Это решение основано на базах данных MySQL, сейчас мы их и настроем.

Итак, для начала скачайте этот файл.

Залогиньтесь в панели управления phpMyAdmin и нажмите кнопку «Import» в верхнем меню.
Теперь, в пункте «File to Import«, нажмите кнопку «Choose File» и выберите файл, который скачали до этого (gpio.sql).
И в завершении нажмите кнопку «Go» внизу страницы.
Это позволит создать все необходимые таблицы.

• Кликнуть на «Users» вверху страницы.
• Теперь жмите на ссылку «Add User«.
• В поле «User name» введите нужное вам имя пользователя. У ввёл «gpio«.
• В поле «Host» введите «localhost«.
• Затем в двух полях введите подходящие пароли. (Без пробелов, переносов или специальных символов). Я ввёл «pr03ND2«.
• Все остальное остальное оставьте по умолчанию, а затем нажмите кнопку «Add User» кнопку в правом нижнем углу.

• Нажмите на кнопку «Users» в верхнем меню, затем пролистывайте вниз до тех пор, пока вы не увидете только что добавленного вами пользователя в таблице «Users Overview«.
• Напротив имени пользователя нажмите на ссылку «Edit Privileges«.
• Листайте внизу к пункту «Database-specific privileges» и выберите «gpio» из выпадающего списка, нажмите кнопку «Go«.
• Отметьте ВСЕ флажки и нажмите кнопку «Go» слева снизу.

Шаг 4. Shell Script

Это та часть, которая запускает проверку значений в базе данных MySQL на Raspberry Pi.
Этот сценарий довольно прост, но требует настройки.

• sudo -i и нажмите Return / Enter
• wget raspberrypi-gpio.googlecode.com/files/GPIOServer.sh и нажмите Return / Enter

• chmod +x GPIOServer.sh и нажмите Return / Enter
• nano GPIOServer.sh и нажмите Return / Enter

• mysqlusername=»ЗДЕСЬ ИМЯ ПОЛЬЗОВАТЕЛЯ»
• mysqlpassword=»ЗДЕСЬ ПАРОЛЬ»

После того как всё изменили, удерживайте клавишу Ctrl и нажмите X, затем отпустите Ctrl и нажмите Y. Нажмите Return / Enter.

Шаг 5. Настройка веб-страницы

Финальный шаг, перед тем как вы сможете использовать это, — настройка веб-страницы.

• wget raspberrypi-gpio.googlecode.com/files/control.php и нажмите Return / Enter
• wget raspberrypi-gpio.googlecode.com/files/off.jpg и нажмите Return / Enter
• wget raspberrypi-gpio.googlecode.com/files/on.jpg и нажмите Return / Enter

• mv control.php /var/www/control.php и нажмите Return / Enter.
• chmod 755 /var/www/control.php и нажмите Return / Enter.
• mv off.jpg /var/www/off.jpg и нажмитеReturn / Enter.
• chmod 755 /var/www/off.jpg и нажмите Return / Enter.
• mv on.jpg /var/www/on.jpg и нажмите Return / Enter.
• chmod 755 /var/www/on.jpg и нажмите Return / Enter.

Теперь вам нужно изменить пару переменных перед использованием файла, поэтому напишите nano /var/www/control.php и нажмите Return / Enter.

• $MySQLUsername = «ЗДЕСЬ ИМЯ ПОЛЬЗОВАТЕЛЯ»;
• $MySQLPassword = «ЗДЕСЬ ПАРОЛЬ»;

Сейчас через браузер зайдите на страницу control.php (у меня raspberryPi/control.php, где raspberryPi — имя хоста.)

Там потребуется ввести следующие данные:
Имя пользователя: admin
Пароль: gpio

Я рекомендую нажать на ссылку «Change Password» сверху страницы и сменить пароль по очевидным причинам.

Шаг 6. Использование

Чтобы запустить программы GPIO, сделайте следующее:
Начните SSH сессию на Raspberry Pi и залогиньтесь как root, затем напечатайте ./GPIOServer.sh и нажмите Return / Enter.

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

Готово! Теперь войдите в панель управления (http://ИМЯ ХОСТА/control.php) и наслаждайтесь!

Для безопасности следует удалить root аккаунт.