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

Для получения качественного звука лучше подключить по USB внешнюю звуковую карту. Помимо улучшения качества аудио, звуковая карта обладает входом для микрофона, что также весьма полезно.

Чтобы не заморачиваться с драйверами я выбрал звуковую карту с чипом c-Media, т.к c-Media работает в Raspbian "из коробки".

Также я приобрёл простой микрофон и аудио набор с двумя трёхватными минидинамиками и усилителем для них, который питается от 5V - 5V можно взять с GPIO разъёма Raspberry Pi.

Чтобы USB звуковая карта использовалась по умолчанию, необходимо внести изменения в файл /etc/modprobe.d/alsa-base.conf,

заменив в нём строчку

options snd-usb-audio index=-2

на

options snd-usb-audio index=0

и перезагрузиться

Для записи звука с микрофона можно воспользоваться программой arecord из пакета alsa-utils:

arecord -D plughw:0 -r 48000 test.wav -d 5

• -D имя устройства
• -r битрейт
• -d длительность записи в секундах
• test.wav имя записываемого файла

Вот так выглядит система в сборе:

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

Проект основан на основе аналогичного для Arduino и Mac OS X.

Скрипт на Python для упрощения проверки сообщений на Gmail использует модуль feedparser, а также модуль RPi.GPIO для управления выводами шины GPIO. Самый простой способ устанавливать модули Python, это менеджер пакетов Pythonpip. Для установки pip используйте команду apt-get.

Замечание: для свежих версий Raspbian (после 15.07.2012) также потребуется пакет с заголовочными файлами python2.7-dev.

Наберите в консоли терминала:

sudo apt-get install python-pip python2.7-dev

Теперь, для того, чтобы pip правильно заработал, нужно обновить пакет distribute с помощью программы easy_install:

sudo easy_install -U distribute

Теперь, с помощью pip установим модули feedparser и GPIO:

sudo pip install feedparser RPi.GPIO

Наконец, все приготовления выполнены. Cкопируйте текст скрипта в файл raspi_gmail.py на Raspberry Pi:

import RPi.GPIO as GPIO, feedparser
USERNAME="username@gmail.com"
PASSWORD="password"
GPIO_PIN=12
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_PIN, GPIO.OUT)
newmails = int(feedparser.parse("https://" + USERNAME + ":" + PASSWORD + "@mail.google.com/gmail/feed/atom")["feed"]["fullcount"])
if newmails > 0: 
	GPIO.output(GPIO_PIN, True)
else: 
	GPIO.output(GPIO_PIN, False)

Теперь осталось только добавить задачу вcronдля запуска каждую минуту. Для этого, откройте для редактирования файл конфигурации командой:

sudo crontab -e

Добавьте эту строку в конце файла (проверьте путь к скрипту):

* * * * * python /home/pi/raspi_gmail.py

Все готово!

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

Оригинал статьи на английском языке: http://mitchtech.net/raspberry-pi-physical-gmail-notifier/?utm_source=rss&utm_medium=rss&utm_campaign=raspberry-pi-physical-gmail-notifier

Оригинал статьи на русском языке: http://www.armlinux.ru/индикатор-новых-сообщений-в-gmail/

Хотелось рассказать об еще одном простом применении Raspberry Pi. Интересно получится ли у вас сделать такой индикатор. Я все делал по инструкции, но почему-то скрипт не работает. Я отредактировал код и теперь этот скрипт просто включает светодиод.

import RPi.GPIO as GPIO
GPIO_PIN=12
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_PIN, GPIO.OUT)
GPIO.output(GPIO_PIN, True)

Надеюсь, что у вас все получится, если вы будете делать подобный индикатор!

Осталось 2 часа до долгой поездки. Собираешь вещи, готовишься. Проверяешь всё. А тут бац! и плеер не работает. Печалька( На телефоне нет памяти, так что не получится с него слушать. Что же делать? Конечно же собирать самому. Особенно если есть Raspberry Pi.

Сначала думаем что он должен уметь:

• кнопка следующая песня
• кнопка пауза
• воспроизводить музыку в случайном порядке
• кнопка выключение
• кнопки звук больше меньше
• светодиод-индикатор

В наличии была ардуинка, куча разных atmeg. Но мой выбор пал на Raspberry pi model B 512 Mb. Решил, что это будет самый простой вариант. У неё есть разъёмы gpio, которые можно использовать для кнопок и светодиода. На малинке стоит Raspbian. Писать решил на python'e через редактор nano, работа c gpio через библиотеку RPi.GPIO, а что бы не мучиться с python кодеками и несовместимостью с arm — буду взаимодействовать со сторонним проигрывателем mplayer через subprocess.Popen(...).

Схема сверх простая

Реализация примерно такая (извините за такой вид. Просто сделано за пол часа...) Фотки

sudo apt-get install mplayer

Эээээх… программа… только не орите! Я знаю что это самое ужасное, что я когда либо писал. Когда ехал сильно мучила совесть. Особенно за использование sleep()
Фейспалмная программа на питоне:

import RPi.GPIO as GPIO
from time import sleep
import subprocess
import os
from random import randint

Mfiles = []

path = "/home/pi/Music/" #Папка, где находится музыка
files = os.listdir(path)
MPFiles = images = filter(lambda x: x.endswith('.mp3'), files); 
i=0
for mf in MPFiles:
    MPFiles[i] = path+mf
    i = i+1

Mfiles = list(MPFiles)

Mlen = len(Mfiles)

count = 1

CurrentSong = 0

i=0
        
while i= 10: #если кнопку держат долго,то выходим
            s = "q"
            LedState = 0
    else: #иначе пауза или воспроизведение
        if i > 0:
            player.stdin.write("p")
            if LedState != 1:
                LedState = 1 #если воспроизведение, то зажигаем светодиод
            else:
                LedState = 2 #иначе моргаем

        i=0

    if GPIO.input(4):	#звук выше
        player.stdin.write("*")

    if GPIO.input(17): #звук ниже
        player.stdin.write("/")

    if GPIO.input(23): #следующая композиция
        player.stdin.write(">")


    
    if LedState == 2: #тут режимы светодиода
        if lastLed == 1:
            GPIO.output(24, GPIO.LOW)
            lastLed = 0
        else:
            GPIO.output(24, GPIO.HIGH)
            lastLed = 1
    else:
        if LedState == 1:
            GPIO.output(24, GPIO.HIGH)
        else:
            GPIO.output(24, GPIO.LOW)

    sleep(0.2) #Фэйспалм 
    
    

player.stdin.write("q") # когда выключаемся, то закрываем плеер

Итак. Почти всё готово. Осталось сделать так, чтоб скрипт запускался при старте нашей малинки

1. редактируем файл

sudo nano /etc/init.d/StartPlayer

2. пишем в редакторе нано это:

#! /bin/sh
# /etc/init.d/StartPlayer
sudo python /путь_к_питнон_скрипту.py

вместо /путь_к_питнон_скрипту.py напишите путь к вашему питон скриптунажимаем ctrl + xYEnter3)

sudo chmod 755 /etc/init.d/StartPlayer
sudo update-rc.d StartPlayer defaults

Всё готово! Загружаем музыку в папку /home/pi/Music/Ставим на вашей SD карточки замок lock, чтобы при случайном выключении питания ничего не сломалось и всё. Плеер готов!!!

P.S. может позже сделаю следующую версию плеера. С нормальным исполнением и программой(без sleep()) и без стороннего плеера

OFFTOPА сейчас я делаю такую милашку ^^

К нему скоро будет камера. Он будет автоматически ездить по квартире. Управление голосом, например «приезжай на кухню». И сам ездить на зарядную станцию.

Привет всем! Сейчас я покажу как можно работать с прерываниями на нашем мини-компьютере, то есть выполнять определенное действие в момент смены сигнала на GPIO.

В этом примере будем записывать в файл время открытия и закрытия двери в комнату. Для этого я подцепил герконовый извещатель от охранной сигнализации между выводами +3.3V и GPIO7 (номер может быть любым).

Выглядит это так:

Здесь задействованы только красный и черный провода, которые идут к извещателю, остальные лишние.

Извещатель состоит из двух частей, это магнит и геркон. Геркон вешаем на дверной косяк, а магнит на саму дверь. Когда магнит находится у геркона (дверь закрыта), его цепь замкнута и на GPIO7 поступает единица. Если же открыть дверь или перерезать провод, то она оттуда исчезнет, о чем мы и запишем в файл.

Программная реализация

Для работы с GPIO нашей малинки существует очень удобная библиотека для Python под названием RPIO (http://pythonhosted.org/RPIO/). Рекомендую всем зайти на этот сайт и изучить документацию и примеры, благо объем ее невелик и написана она несложным языком. Итак, для начала собственно установим Python

sudo apt-get install python python-setuptools

И библиотеку RPIO

sudo easy_install -U RPIO

Создадим файл нашего скрипта с названием, к примеру, door.py. Дадим ему права на исполнение:

chmod +rx door.py

Заполним этот файл следующим содержимым:

#!/usr/bin/python
# -*- coding: utf-8 -*-
import RPIO # Импортируем библиотеку RPIO
import time # ...и для работы со временем
input_pins = (7,8,9,10) # Задаем номера пинов, которые будут использоваться под ввод. Лучше внести в этот список побольше пинов, дабы избежать наводок.
for i in xrange(len(input_pins)): # Включаем их на ввод и подтягиваем к земле
RPIO.setup(input_pins[i], RPIO.IN, pull_up_down=RPIO.PUD_DOWN)
door = open('/home/pi/door', 'a',0) # Открываем файл в который будем записывать инфу. 'a' означает режиме записи в конец файла 0 - отключить буферизацию, чтбы информация записывалась незамедлительно.

def write_door_state(gpio_id, val): # Создаем функцию, запускаемую при изменении состояния GPIO
	if val==0: 
		door.write (time.strftime("%d.%m.%Y %H:%M:%S")+"\tОткрытие\r\n") #\t - символ табуляции, \r\n - перевод строки
	else:
		door.write (time.strftime("%d.%m.%Y %H:%M:%S")+"\tЗакрытие\r\n")
RPIO.add_interrupt_callback(7, write_door_state,pull_up_down=RPIO.PUD_DOWN,threaded_callback=True, debounce_timeout_ms=50) #Добавляем прерывание, с подтяжкой к земле и подавлением дребезга контактов

RPIO.wait_for_interrupts() # Запускаем ожидание прерываний

Чтобы наш скрипт запускался от имени суперпользователя (а иначе он работать не будет) при старте системы, необходимо в файл /etc/rc.local перед строчкой exit 0 записать путь к нашему скрипту и добавить амперсанд (&) в конце, например

/home/pi/door.py&

Также можно для удобства в файл ~/.bashrc добавить строки

echo "Последние 10 событий двери:"
tail door

Теперь при каждом входе в систему будет выводиться последние 10 строк из нашего лога:

Последние 10 событий двери:
26.08.2013 14:24:52     Открытие
26.08.2013 14:25:03     Закрытие
27.08.2013 01:37:57     Открытие

Собираем на макетной плате и реализуем на "Си" симулятор светофора с кнопкой - простой пример для начала изучения работы с GPIO.

Вместо вступления

В этой записи я хочу рассказать об одном из первых моих проектов, который объясняет основы работы с GPIO выводами Raspberry Pi. Этот проект не является простейшей мигалкой, которую писал, наверное, каждый обладатель Малины, и также не является супер-сложным проектом, который новичку просто не потянуть.Сразу оговорюсь, что идея проекта принадлежит не мне, а одному английскому разработчику - Гордону Хендерсону, который, кстати, написал и библиотеку для Си, которая была использована в проекте. Запись, в принципе, является описанием проекта с моей стороны. Писалась она для новичков, с целью показать основы программирования для работы с GPIO. Теперь, когда все дисклеймеры написаны, приступим к делу.

Идея

Идея заключается в сборке макета (симуляции) светофора с кнопкой, а точнее даже двух светофоров - автомобильного и пешеходного, которые связаны той самой кнопкой. Суть таких светофоров в том, что зеленый свет для пешеходов включается по требованию (читай - по нажатию кнопки). Такой тип светофоров очень распространен в США, где пешеходов в небольших городах довольно мало. Принцип работы таков: Во время простоя автомобилям все время горит зеленый, а пешеходам - красный. По нажатию на кнопку автомобильный светофор останавливает движение, после чего пешеходный светофор зажигает зеленый свет, тем самым разрешая пешеходам перейти улицу. Через некоторое время (не будем его уточнять, это не столь важно) светофоры снова возвращаются в исходное положение: зеленый для машин и красный для пешеходов.

Реализация

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

Сборка схемы

Для сборки схемы данного проекта нам понадобится:

1. Пластиковая макетная плата. Подойдет любая, я использовал похожую на эту .
   

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

3. Резисторы. Я использовал резисторы в 330 Ом, но можно использовать и большего номинала. Однако не советую использовать номинал выше 1,5 кОм. Резисторов нужно шесть - пять для светодиодов, и один для кнопки.
   

4. Кнопка. Тут уточнять нечего, кроме того, что она должна быть замыкающей, а не размыкающей.
   

Также вам понадобится что-то, чтобы соединять нашу макетную плату и выводы GPIO на Малине. Тут уже выбор за вами, скажу лишь что я для этих целей использовал обрезанный IDE шлейф, второй конец которого распаял на 26 DLS-штырьков, который вставляются прямиком в макетку. Как это примерно будет выглядеть в собранном виде и визуальная схема сборки приведена ниже. Советую пользоваться именно графической схемой для сборки.

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

Пишем программу.

Писать будем на "Си", с использованием библиотеки wiringPi, автором которой является все тот же Гордон Хендерсон. Эта библиотека имеет упрощенный синтаксис и очень схожа с библиотекой для написание скетчей для Arduino. Мне, как новичку, было намного приятнее и удобнее работать с ней, чем со стандартной библиотекой, синтаксис которой читается и воспринимается сложнее. Для начала установим библиотеку. Это сделаем в два шага, выполнять которые нужно в консоли RaspberryPi. Если у Вас уже установлен пакет GIT-core, то первый шаг можно смело пропускать.

Шаг 1: Устанавливаем GIT:

sudo apt-get install git-core
sudo apt-get update
sudo apt-get upgrade

Шаг 2: Скачиваем и компилируем wiringPi:

git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
./build

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

Теперь создадим в удобном для вас месте файл walk.c:

touch walk.c

Откроем его:

nano walk.c

И заполним следующим кодом. Этот код и есть кодом для нашей программы, то как он работает я попытался максимально объяснить в комментариях:

//**********Подключаем необходимые библиотеки************
#include "wiringPi.h"  //Библиотека для работы с GPIO
#include "stdio.h"
#include "stdlib.h"
//**********Назначаем буквенные метки номерам пинов******
#define RED 0   //Красный автомобильный
#define YEL 1   //Желтый автомобильный
#define GRE 2   //Зеленый автомобильный
#define P_RED 3 //Красный пешеходный
#define P_GRE 4 //Зеленый пешеходный
#define BUT 8   //Кнопка
//-------------------------------------------------------
void init() {
  if (wiringPiSetup () == -1) //Инициализация wiringPi
    exit (1);
//**********Устанавливаем пины светодиодов в режим вывода
  pinMode (RED, OUTPUT); 
  pinMode (YEL, OUTPUT);
  pinMode (GRE, OUTPUT);
  pinMode (P_RED, OUTPUT);
  pinMode (P_GRE, OUTPUT);
//-------------------------------------------------------
  pinMode (BUT, INPUT); // Пин кнопки ставим в режим ВВОДА

//**********Устанавливаем изначальную комбинацию ********
// Функция записи значения имеет следующий синтаксис:
// digitalWrite(номер_пина, состояние)
//Состояния: LOW - светодиод не горит, HIGH - светодиод горит
  digitalWrite(RED, LOW);
  digitalWrite(YEL, LOW);
  digitalWrite(GRE, HIGH);
  digitalWrite(P_RED, HIGH);
  digitalWrite(P_GRE, LOW);
//-------------------------------------------------------
  printf("Okay..\n"); //Выводим в консоль как знак завершения инициализации
}

//********Функция ожидания нажатия кнопки****************
void button_wait() {
	printf("Ожидание нажатия...\n");
	//Пока состояние кнопки = HIGH (логическая единица) - ждем одну милисекунду
	while(digitalRead(BUT)==HIGH) {
		delay(1);
	}
	//Как только состояние изменится цикл прервется и в консоль будет выведена надпись
	printf("Нажато!\n");
}
//-------------------------------------------------------

//********Функция остановки трафика**********************
void stop_traff() {
	int i;
	printf("Останавливаем движение...\n");
	// Трижды мигаем зеленым светом для автомобилей
	for(i=0; i<3; i++){
		digitalWrite(GRE, LOW);
		delay(500);
		digitalWrite(GRE, HIGH);
		delay(500);
	}
	// Выключаем зеленый для автомобилей, включаем желтый
	digitalWrite(GRE, LOW);
	digitalWrite(YEL, HIGH);
	//Ожидаем три секунды, выключаем желтый и включаем красный для автомобилей
	delay(3000);
	digitalWrite(YEL, LOW);
	digitalWrite(RED, HIGH);
}
//-------------------------------------------------------

//********Функция запуска пешеходов**********************
void p_start() {
	//Выключаем пешеходный красный, затем включаем зеленый. Выводим в консоль надпись.
	digitalWrite(P_RED, LOW);
	digitalWrite(P_GRE, HIGH);
	printf("Можно идти!\n");
}
//-------------------------------------------------------

//********Функция восстановления режимов*****************
// Запускается по истечению времени движения пешеходов.
void change_time() {
	printf("Окончание перехода..!\n");
	int i;
	// Выключаем красный для автомобилей и зеленый для пешеходов
	digitalWrite(RED, LOW);
	digitalWrite(P_GRE, LOW);
	//Трижды мигаем одновременно зеленым для пешеходов и желтым
	for(i=0; i<3; i++){
		digitalWrite(P_GRE, HIGH);
		digitalWrite(YEL, HIGH);
		delay(500);
		digitalWrite(P_GRE, LOW);
		digitalWrite(YEL, LOW);
		delay(500);
	}
}
//-------------------------------------------------------

//********Функция запуска автомобилей********************
void start_traff() {
	printf("Движение автомобилей восстановлено.\n\n");
	//Включаем зеленый для автомобилей и красный для пешеходов
	digitalWrite(GRE, HIGH);
	digitalWrite(P_RED, HIGH);
}
//-------------------------------------------------------

//*****Главная функция, в которой будут вызваны остальные
int main() {
	printf("__________________Симулятор светофора_________________\n");
	init();
	for( ; ; ){ //Повторяем бесконечное число раз
		button_wait(); // Ожидаем нажатие кнопки, код снизу будет выполнен только после нажатия
		stop_traff(); // Останавливаем автомобили
		delay(1000); // Ждем секунду, прежде чем запустить пешеходов
		p_start(); // Запускаем пешеходов
		delay(5000); //Время для движения пешеходов - 5 секунд
		change_time(); // Режим восстановления движения
		start_traff(); // Движение восстановлено
	}
// Чтобы завершить программу нужно нажать Ctrl+C
	return(0);
}

Теперь сохраним наш файл комбинациейCtrl+O и закроем его комбинацией Ctrl+X (комбинации актуальны при использовании текстового редактора nano). Для запуска нашей программы нам нужно её скомпилировать. Делается это следующей командой в консоли:

gcc -Wall -o walk walk.c -lwiringPi

Теперь запускаем:

sudo ./walk

Если вы все сделали правильно - загорится зеленый светодиод на "светофоре" для автомобилей и красный на "светофоре" для пешеходов.По нажатию на кнопку выполнится программа. То, как эта программа работает можно посмотреть на видео - http://youtu.be/R_jUUYhD0BU Если что-то работает неправильно - значит на каком-то из этапов вы допустили ошибку. Проверьте все очень внимательно и попробуйте еще раз.

Заключение.

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

Прочитав статью про подключения к Малине облачного диска "Яндекс.Диск" я решил повторить описанное у себя на малине.Проблема в том, что экосистемой Яндекса я не пользуюсь, а регистрировать аккаунт ради одного только "Диска" - не вижу смысла. К тому же у меня уже есть аналогичный сервис от Google - "Google Drive"

Покопавшись в интернете, собрав из кусков информацию я сумел подключить гуглодиск. Как это сделать опишу ниже. Замечу только, что инструкция рассчитана на то что у вас уже есть аккаунт GoogleDrive. Если нету - вы всегда можете зарегистрировать его здесь https://drive.google.com/

Итак, приступим.

Для начала зайдем на сайт http://dav-pocket.appspot.com/ . Тут нам нужно зарегистрировать аккаунт. Это нужно потому, что изначально Google Drive не поддерживает протокол WebDav, а наш софт, который мы будем использовать для монтирования работает именно с ней. Сайт выступает в роли промежуточного звена - он берет данные из Google Drive и как бы выставляет их в виде WebDav. Для регистрации нужно нажать оранжевую кнопку "Sign up", после чего ввести желаемое имя пользователя и пароль (дважды). Подтверждение по Email не требуется, так что вас сразу перенаправят на следующую страницу, где нужно будет нажать кнопку "Authorize DAV-pocket service". По её нажатию Вас перенаправит на страницу гугла, где Вы должны будете предоставить доступ к Вашему аккаунту. После проделанного вас перебросит на страницу, где вам будут выданы данные для подключения, а именно Server Adress (адрес сервера), Login (логин) и Password (пароль :). Можете оставить эту вкладку открытой, или просто сохраните эти данные - они понадобятся нам во время следующих действий. Когда все описанное выше проделано, вооружимся консолью Raspberry Pi и выполним в нем следующие команды: 1. Установим davfs2:

sudo apt-get install davfs2

Соглашаемся на то, чтобы система скачала архив.2. Перенастроим пакет davfs2

sudo dpkg-reconfigure davfs2

В открывшемся интерфейсе выбираем "Да". Этим мы позволим монтировать систему непривилегированным пользователям ОС.3.Добавим нашего пользователя в группу davfs2

sudo usermod -aG davfs2 pi

pi - это имя пользователя. Если вы меняли стандартное имя то впишите вместо "pi" имя вашего пользователя. 4. Создадим папку, куда будет монтироваться наше облако.

mkdir Gdrive

Опять же. "Gdrive" - имя папки. Вы можете выбрать любое которое нравится Вам, но в дальнейшем инструкция будет написана именно для этого имени файла. 5. Настроим параметры авторизации.

sudo nano /etc/davfs2/secrets

Откроется файл, в конец которого надо добавить запись формата:

https://dav-pocket.appspot.com/docso [Логин выданный сайтом] [пароль выданный сайтом]
Логин и пароль нужно ввести без квадратных скобок. То есть, к примеру, если сайт выдал Вам логин "Login123", а пароль "parol", то запись будет такой:

https://dav-pocket.appstot.com/docso Login123 parol
Сохраняем файл -Ctrl+O и закрываем его - Ctrl+X6. Настраиваем автоматическое монтирование.Для того чтобы наше облако автоматически монтировалось при инициализации сетевого интерфейса нам нужно отредактировать файл fstab

sudo nano /etc/fstab

В него нужно дописать следующую строку (в конец)

https://dav-pocket.appspot.com/docso [абсолютный путь к папке монтирования] davfs uid=1000,user,rw,_netdev 0 0

абсолютный путь к папке указывается БЕЗ квадратных скобок, и выглядеть должен как путь из корня файловой системы. Например если Вы создали папку Gdrive в домашней папке пользователя pi, то путь будет выглядеть так:

/home/pi/Gdrive
Сохраняем файл - Ctrl+O и закрываем его - Ctrl+X, по уже знакомой нам схеме.Теперь осталось только перезагрузить Малинку для проверки автоматического монтирования.

sudo reboot

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

Управление освещением и голосовое оповещение о погоде. Пример кода и электрическая схема подлючения реле к Raspberry Pi. Запилил видео, где рассказываю о простейшем применении "малинки".

Предварительно установитеmplayer и alsa:

sudo apt-get install alsa-utils
sudo apt-get install mplayer

Также установите pip для Python, для легкой установки пакетов. И затем c его помощью установите feedparser. Рассказывать не буду, проще найти информацию по запросу "install pip python" в гугле )

Сам код для скрипта WebIOPi:

# заставляем работать с кодировкой utf8, необходимо для гугло транслита
# -*- coding: utf-8 -*-
# импорт модулей
import webiopi
import subprocess
import feedparser

# получаем GPIO
GPIO = webiopi.GPIO

# константы на нумерацию портов GPIO
LIGHT = 23
LIGHT2 = 18
BUTTON1 = 17
BUTTON2 = 22

def setup():
    # конфигурируем пины GPIO
    GPIO.setFunction(LIGHT, GPIO.OUT)
    GPIO.setFunction(LIGHT2, GPIO.OUT)
    GPIO.setFunction(BUTTON1, GPIO.IN)
    GPIO.setFunction(BUTTON2, GPIO.IN)

def loop():
	# ловим нажатие кнопки 1
	if (GPIO.digitalRead(BUTTON1) == GPIO.HIGH):
		# инвертируем значение на пине (программный свитч)
		GPIO.digitalWrite(LIGHT, not GPIO.digitalRead(LIGHT))
	# ловим нажатие кнопки 2
	if (GPIO.digitalRead(BUTTON2) == GPIO.HIGH):
		# предупреждаем о задержке
		subprocess.call(["mplayer", "http://translate.google.com/translate_tts?tl=ru&ie=UTF-8&q=Пожалуйста, ожидайте, запрашиваю погоду."])
		# вытаскиваем погоду
		d = feedparser.parse('http://rp5.kz/rss/76334/ru')
		# читаем погоду
		subprocess.call(["mplayer", "http://translate.google.com/translate_tts?tl=ru&ie=UTF-8&q="+d.entries[0].title])

def destroy():
	# заканчиваем работу, выключаем свет )
    GPIO.digitalWrite(LIGHT, GPIO.LOW)

Схема:

Транзистор любой NPN структуры, я использовал советский КТ961Б, для работы в режиме коммутации подойдет любой. Сопротивление подобрать для необходимого тока открывания транзистора. Реле я взял SRI-05VDC-SD-C с напряжением 5 вольт и максимальным током для контактов 10А. Диод 1N4001 вроде, необходим для уберания эффекта самоиндукции катушки реле, иначе попалим транзистор и ногу малинки. Земля на транзисторе общая с питанием реле и малиной. НИ В КОЕМ СЛУЧАЕ НЕ ПИТАЙТЕ РЕЛЕ ОТ GPIO! Спалите нахрен малину) Перед питанием можно включить реле. А так желательно отдельный источник питания для таких штук. Реле можно и на 12 вольт.Просьба не винить меня за спаленные малины, делаете все на свой страх и риск. Необходимо уметь держать паяльник и знать основы работы с электрическими цепями. Осторожнее в цепях 220 вольт! Это смертельно.

Нет, это не то, о чём Ты, дорогой читатель, думаешь. Я не создавал образа через загрузчик, не вырезал приложения из Raspbian, и так далее по списку извращений с готовым образом. Сегодня Мы поговорим о Minibian и настройке WM (оконного менеджера) в целях сохранения ОЗУ и мощности ЦП. Кому интересно - прошу, красноглазим).

Скачаем и запишем образ, лежит здесь: ТЫЦ

После загрузки - голая консоль.... Едем далее. Пока будем смотреть в паутину через Ethernet-port.

apt update - обновляем список пакетов

apt install firmware-brcm80211 pi-bluetooth wpasupplicant firmware-realtek wpasupplicant -y - устанавливаем драйвера

Теперь можно поднять Wi-Fi:

Поправим файл /etc/network/interfaces . Пропишем там

allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Теперь поправим файл /etc/wpa_supplicant/wpa_supplicant.conf . Пропишем там

network={
ssid="Имя вашей сети"
psk="Пароль"
}

Перезагружаемся, можно вытащить Ethernet.

apt install nano sudo rpi-update raspi-config -y - устанавливаем текстовый редактор, sudo, специальную утилиту обновления, утилиту конфигурации

Запустим raspi-config. Там нажмём:

expand_rootfs - здесь вы можете увеличить корневой раздел на всю SD

configure_keyboard - в этом пункте вы можете выбрать драйвер клавиатуры

change_locate - установка языка

change_timezone - выбор часового пояса.

memory_split - управление памятью видеочипа. Здесь стоит выбрать 128M для работы с 180p 60FPS, так как память видеочипу выделяется из ОЗУ

overclock - разгон процессора. Сильно, думаю, гнать не стоит. Можно повредить SD и увеличить температуру ЦП. При разгоне рекомендую иметь хорошую карту памяти, радиаторы и куллер на ЦП

ssh - включение или выключение сервера удалённого доступа SSH.

Далее нажимаем Ctrl+F и соглашаемся на перезагрузку.

rpi-update - обновимся

adduser pi - добавим пользователя в систему.

usermod -a -G sudo pi - дадим пользователю возможность использовать sudo

visudo - откроем настройки sudo

И пропишем: pi ALL=(ALL) ALL

Сохранимся.

Снова перезагрузимся, и войдём теперь уже под пользователя pi.

sudo apt install xorg - установим графический сервер.

Изменим файл ~/.xinitrc Пропишем там: exec openbox-session

Сохранимся

Далее

nano -w ~/.bash_profile - откроем редактором файл ~/.bash_profile

И пропишем там: [[ $(fgconsole 2>/dev/null) == 1 ]] && exec startx -- vt1

Сохранимся

nano -w /etc/inittab - откроемредакторм файл /etc/inittab и пропишем там: c1:2345:respawn:/sbin/agetty -a pi -8 -s 38400 tty1 linux

А так же поставим # перед существующей похожей строкой

Сохранимся

sudo apt install openbox obenbox-themes obconf obmenu tint2 feh lxterminal lxappearance -y - установим WM, панель, апплеты, терминал и утилиты для настройки.

Скачаем картинку для обоев, например файл 1.jpg в домашнюю папку.

Теперь откроем файл ~/.fehbg

И пропишем там: feh --bg-scale '/home/pi/1.jpg'

Сохранимся

Теперь настроим панель, я предпочитаю настройки от Manjaro, его можно взять тут: ТЫЦ.

Скопируем конфиг в файл ~/.config/tint2/tint2rc

Теперь настроим Openbox. Обои мы почти установили, откроем файл ~/.config/openbox/autostart.sh и пропишем там:

xmodmap ~/.Xmodmap &
feh --bg-scale /home/pi/1.jpg &
tint2 &
Сохранимся

Теперь запустим графику: startx

Если всё сделали правильно - перед нами будут обои, панелька и меню приложений по ПКМ. Им и займёмся. Запустим obmenu.

Там видны все подпапки. С помощью кнопки + можно добавить приложение. Появятся графы Name, Execute. Name - имя приложения в меню, Execute - само приложение. Например Name=Terminal, Execute= lxterminal, то в меню появится строка Terminal, кликнув по которой, мы запустим lxterminal. Удалять приложения из меню кнопкой -.

Тепеь запустим obconf. Там можно выбрать тему окон, добавить или убрать кнопки окон и многое другое. Настройка также через графику.

Теперь запустим lxappearance. Также загрузим иконки и по желанию gtk-тему. Установим их в меню lxappearance.

Впринципе, настройка openbox окончена, более подробно тут: ТЫЦ. Установим нужные приложения, приведу небольшой список легковесных:

luakit - браузер

pcmanfm - файловый менеджер

leafpad - текстовый редактор

lxmusic - аудиоплеер

vlc - видеоплеер со всеми кодеками

libreoffice - офис

p7zip и unrar - архиваторы

И очистим кеши, а также удалим не нужное:

sudo apt purge obconf obmenu raspi-config lxappearance
sudo apt clean
На сим, думаю, всё. Ман написал для конкурса "Автор Месяца".

В данной статье я опишу историю о том,как я пытался запустить WineHQ и что из этого вышла.

Внимание!Статья довольно бредовая :).Слабонервным лучше не читать.

В конце статьи расскажу как запустить Windows

Данная история началась уже довольно давно,еще в прошлом году меня посетила эта поистине бредовая затея.

После непродолжительных поисков я наткнулся на статью о том,как кому-то удалось скомпилировать Wine для Малинки.Понимая головой,что Windows приложения написаны для x86/x64 ,а Малинка имеем ARM процессор я все таки решил попробовать посмотреть ,что получится.

Загрузив исходники я запустил их компиляцию на Raspberry Pi и пошел спать.

На утро я увидел,что все собралось без единой ошибки и на лице появилась глупая улыбка

И что с этим делать?
Да ничего на самом деле.Мне удалось собрать блокнот(notepad.exe) из React OS для малинки и запустить его.

А если я хочу и правда запустить x86 приложения ?
Тогда есть QEMU и ExaGear Desktop!

Чтож,будем запускать Windows в Qemu

sudo apt-get install
sudo apt-get uprage
sudo apt-get install git zlib1g-dev libsdl1.2-dev libpixman-1-0 libpixman-1-dev

Загрузим исходник

git clone git://git.qemu-project.org/qemu.git

Теперь мы соберем программу из исходника

cd qemu
./configure --target-list="i386-softmmu" --enable-sdl --prefix=/usr
sudo make

Отладка может продолжаться неопределённое время, (~15-20 минут). Последнее, что мы должны сделать, это подправить конфигурации и отладить.

sudo nano /home/pi/qemu/tcg/arm/tcg-targe­t.c
sudo nano /home/pi/qemu/tcg/i386/tcg-targ­et.c

Зажимаем Ctrl+W, открывается строка поиска, вводим: static void tcg_out_addi. Меняем на static inline void tcg_out_addi. Переходим ко второму конфигу, так же вызываем строку поиска и вводим этот текст: static void tcg_out_opc и меняем на static inline void tcg_out_opc. Если вы не нашли какую-то из строк, то ничего не делаем, а просто закрываем конфиг и выполняем следующий шаг (в первом конфиге я не нашёл нужную строку, однако эмулятор у меня работает нормально).

Идем дальше.

sudo make
sudo make install

Загрузим образ отсюда

В директории с образом выполним

qemu-system-i386 здесь тип образа (-hda, -fda, -cdrom) НазваниеВашегоОбраза.img -m
Тут_Кол-во_ОЗУ_В_МБ(Без подчёркиваний)

Если все было сделать правильно,то начнется загрузка системы.Медленно,но начнется,правда

Статья для тех,кому не хватает средств на новый DOOM ,хочется поностальгировать или для тех кто делает эмулятор консолей на Raspberry Pi.

Загрузим саму игру в /home/pi

wget https://www.chocolate-doom.org/downloads/2.2.1/chocolate-doom-2.2.1.tar.gz

Установим нужные пакеты

sudo apt-get update
sudo apt-get install gcc build-essential libsdl1.2-dev libsdl1.2debian libsdl-image1.2 libsdl-image1.2-dev libsdl-mixer1.2 libsdl-mixer1.2-dev libsdl-net1.2 libsdl-net1.2-dev timidity

Распакуем архив с игрой

tar zxvf chocolate-doom-2.2.1.tar.gz

Соберем и установим

./configure
sudo make
sudo make install

Отлично! В принципе все готово, но для того, чтобы DOOM избавился от мелких фризов надо настроить Chocolate Doom. Для этого сделаем следующее:

Введем в терминале

chocolate-doom-setup

Эта команда запустит окно напоминающее DOS. Идем в Display configuration, нажимаем "A" на клавиатуре, убираем точку с пункта Fix aspect ratio, а затем выставляем оконный режим и разрешение экрана от 1280x800 и ниже. Сохраняем.

Осталось запустить DOOM. Для этого нам понадобится .wad файл. Скачиваем эти 2 .wad файла, кидаем в /home/pi и запускаем

chocolate-doom -iwad ~/имяфайла.wad
По всем вопросам можете обращаться в комментарии,постараюсь помочь

Если не получилось,то не расстраиваемся,ведь DOOM есть также в магазине приложений для Raspberry Pi

Как вы все наверное знаете в linux есть полезная команда Wget - благодаря ней вы сможете скачивать файлы по HTTP протоколу с серверов. Ну так вот иногда может возникать потребность сохранять скачиваемый файл под другим именем. Так вот делается это при помощи "Настройки"-O. Вот пример её использования:

wget http://google.com -O google.html

В Linux есть одна классная команда называется watch. Благодаря ней вы сможете повторять одну и ту же команду за n количество секунд. Вот вам пример её использования:

watch -n 9 python myscript.py

Эта команда будет запускать скрипт myscript.py каждые 9 секунд

Самой большой моей мечтой за долгие годы, было посидеть в тишине, а не слушать как многочисленные вентиляторы с завыванием гоняют пыль в пылающих недрах БЭСМ, а им вторят неутомимым стрекотанием диски, вечно чем-то озадаченные.

Итак, перфокарты в мусорку, ноут другому страдальцу, а Raspberry Pi 3 model B прикручена к спине монитора. Что мы имеем? Топовое железо уровня 2005 года и проблему с узким бутылочным горлышком в виде дискового ввода-вывода.

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

Вижу, что количество тех кто остался значительно сократилось, но это самые смелые люди. Хорошо, тогда продолжим и примем вызов брошенный нам в лицо этими творцами неуемных в своем аппетите программ. Давайте раздробим проблему на более мелкие и не связанные с собой части. Увеличим размер доступной памяти, попробуем свести к минимуму обращение к диску (под ним будем иметь в виду нашу SD-карту), избавимся от "лишних" занимающих память программ.

Часть первая

Увеличь свою память быстро! без рекламы регистрации и смс Физически увеличить память на устройстве не получится. Но руки опускать рано ведь в линуксе есть zram.

zRam — модуль ядра Linux. Он увеличивает производительность путём предотвращения подкачки страниц на диск, используя сжатое блочное устройство в оперативной памяти, пока не появится необходимость использовать файл подкачки на жёстком диске. Скорость обмена с оперативной памятью быстрее, чем с жёстким диском, следовательно zRam позволяет Linux производить большее число операций подкачки, особенно на старых компьютерах с малым объёмом оперативной памяти.

Добавляем в конец файла /etc/rc.local инициализацию и запуск модуля zram (перед строкой exit 0):

modprobe zram num_devices=4  # Пусть все 4 ядра будут задействованы для компрессии

SIZE=512    # Отдадим под псевдо свап-файл 512 Мб
echo $(($SIZE*1024*1024)) > /sys/block/zram0/disksize
echo $(($SIZE*1024*1024)) > /sys/block/zram1/disksize
echo $(($SIZE*1024*1024)) > /sys/block/zram2/disksize
echo $(($SIZE*1024*1024)) > /sys/block/zram3/disksize
mkswap /dev/zram0
mkswap /dev/zram1
mkswap /dev/zram2
mkswap /dev/zram3
swapon /dev/zram0 -p 10
swapon /dev/zram1 -p 10
swapon /dev/zram2 -p 10
swapon /dev/zram3 -p 10

Файл доступен на запись только пользователю root, так что не забудьте $
sudo leafpad /etc/rc.local

Часть вторая

Посади толстяка на диету

В качестве ежовых руковиц мы возьмем расширения для хрома OneTab которое группирует все открытые вкладки в одну (а одна открытая вкладка = запущенному процессу = съеденной памяти) и uMatrix который фильтрует контент страницы удаляя рекламу, скрипты фреймы, аудио и видео. Если uMatrix покажется вам слишком агрессивным, попробуйте uBlock Origin.

Часть третья

Все ненужное на слом, соберем металлолом! Ребята колдующие над Raspbian и так постарались основательно подчистив lxde и дальнейшее творчество рассчитано исключительно на людей сильных духом и обладающих пытливым умом.

Поскольку я давно заметил что наблюдаю красивые обои только после включения компьютера, а затем они быстро пропадают под многочисленными окнами, то если их не будет, ничего страшного не случиться. Тоже относиться и к обрамлению окон. Ну а если так, то почему бы не попробовать в меру аскетичный оконный менеджер что-то вроде awesome, dwm, wmii, larswm, 9wm, w9wm...

Странно, почему они все пытаются в той или иной мере воссоздать окружение Plan9? Лично я возьму plan9port от Расса Кокса и скомпилирую его. Но предварительно нужно поставить необходимые библиотеки для сборки.

$ sudo apt install libx11-dev libxext-dev libxt-dev

Скачанный plan9port-master.zip сохраню в /opt/plan9port распакую и запущу компиляцию $ ./INSTAL После сборки создадим файл ~/.xsession следующего содержания

export PLAN9=/opt/plan9port
export PATH=$PATH:$PLAN9/bin
export LANG=en_US.UTF-8
font=$PLAN9/font/lucm/unicode.9.font
GS_FONTPATH=$PLAN9/postscript/font
home=$HOME
prompt="$H=;  "
user=$USER
export \

GS_FONTPATH \
font \
home \
prompt \
user\
plumber &
/home/pi/riostart &

exec rio

Еще один файл ~/riostart для "автозапуска" нужных вам приложений

#!/opt/plan9port/bin/rc
stats -W 100x100@0,0 -lmsew &
xclock -geometry  100x100+0+100 &
9term -W 500x300@300,770 &
9term -W 310x200@1600,870 &

Сделаем его исполняемым $ chmod a+x ~/riostart

Ну и напоследок, добавим в конец ~/.bashrc пару строк

PLAN9=/opt/plan9port export PLAN9
PATH=$PATH:$PLAN9/bin export PATH

Почитать про Plan9 , оконный менеджер Rio и редактор Acme можно на вики.

Выглядит необычно первые пару дней, но к этому скоро привыкаешь.

Чтобы загружалась ваша привычная оконная среда вам понадобиться удалить или переименовать файл .xsession

$ mv ~/.xsession ~/.xsession.old

Желаю Вам быстрой и приятной эксплуатации малинки!

Заказал себе Raspberry Pi 3 с комплектом датчиков. Заказал не потому что человек рукастый и разбираюсь в скупых строчках программного кода. Этого как раз нет. Обычный пользователь ПК и операционной системы под названием Windows.

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

Но я как раз о другом. Многое очевидно. Машинка, робот, планшет, квадрокоптер, камера, игровая приставка, аудиоплеер ну и т.п. Это то, что как бы у всех и так есть или может быть (надо просто заказать на Алибабе) без приложения серьезных усилий и большого объема затрат времени..

И в основном, судя по постам этого блога, люди используют Raspberry для приятного время препровождения: заставляют мигать светодиод по созданной ими программе, отключать свет и всякое такое. Но почему только это? Почему только очевидное?

На что еще можно рассчитывать? Практическое? Например, устройство, предупреждающее об опасном уровне дыма в комнате для курения? Или анализатор метеоусловий (не информер, а анализатор) с выдачей информации, необходимой для сбережения здоровья?

Это примеры, как бы, с потолка. И я понимаю, что все это как раз и реализуемо. Предложений почему-то не видно. И вот к чему я все это пишу. Хочу сформировать группу молодых и талантливых разработчиков и конструкторов для реализации интересных проектов на Raspberry Pi 3 к взаимной выгоде. Буду рад любым идеям!

Особенности- управляется через bluetooth с android-планшета

• транслирует видео- определяет расстояние до предметов перед собой
• фары для движения в темноте
• более 4-х часов работы без подзарядки
• всё программирование raspberry сделано на Java

Детали по реализации и инструкция

http://privateblog.info/lego-vezdexod-s-video-i-bluetooth/
http://privateblog.info/dorabotka-lego-vezdexoda/

Знаете ли вы, что существует открытое решение, позволяющее создать домашний облачный сервер наподобие Google Drive на Raspberry Pi?

Nextcloud — это клиент-серверное программное обеспечение для создания приватных облаков, где файлы хранятся на жёстком диске у вас дома или в офисе и больше нигде. Файлы доступны только вам и вашим друзьям. Обменивайтесь фотографиями, редактируйте документы, настраивайте права доступа с помощью приложений для Windows, Mac OS, Linux, Android и iOS.

Добрые ребята из компании Google анализируют содержимое файлов в Google Drive, но у них нет физического доступа к файлам в домашних облачных хранилищах. В этом главное отличие приватных облаков на основе Nextcloud от Google Drive, Dropbox, Яндекс.Диск и т.п.

Пару лет назад мой друг Максим скопировал все свои фотографии и видеозаписи на домашний неттоп, установил ownCloud(предшественник Nextcloud), купил статический ip-адрес у интернет-провайдера и открыл доступ через интернет для друзей. Получилось домашнее облако. Мы ездили в горы, много фотографировались и загружали фотографии в домашнее облако Максима через приложение Nextcloud.

Недавно я подключил 1 ТБ жесткий диск к Raspberry Pi 3, установил Nextcloud Server 11 и запустил собственное домашнее облако. Установка и настройка Nextcloud Server оказалась самым сложным для меня и заняла два часа. Инструкция на официальном сайте написана для системных администраторов, а не для рядовых пользователей. Мне пришлось скачивать файлы через wget, править конфигурационные файлы через vim, настраивать веб-сервер, СУБД, PHP и т.д. И вот, чтобы вам сэкономить время, команда разработчиков cusbeb.com подготовила образ для SD-карты с установленным и настроенным Nextcloud Server 11.

Нажмите здесь, чтобы скачать образ

На всякий случай, вот исходники.

Итак, простой способ создать домашнее облако:

1. Скачайте образ для вашей модели Raspberry Pi по ссылке выше.

2. Запишите образ на SD-карту и вставьте в Raspberry Pi.

3. Отформатируйте внешний HDD или USB-флешку в NTFS и подключите к Raspberry Pi. Обращаю ваше внимание, что хранилище данных должно быть подключено к Raspberry Pi до включения питания.

4. Подключите Raspberry Pi к локальной сети или к роутеру.

5. Включите питание. Внимание! При первом запуске на инициализацию образа требуется 5 минут.

6. Узнайте адрес Raspberry Pi в локальной сети, допустим это x.x.x.x.

7. Запустите браузер на любом устройстве, подключенном к локальной сети, и в браузере наберите http://x.x.x.x:8001/nc

8. Если вы всё сделали правильно, то увидите страницу завершения настройки Nextcloud Server. Придумайте логин и пароль администратора и нажмите кнопку Завершить установку. Пожалуйста, не меняйте значения в заполненных полях из раздела Хранилище и база данных.

9. Если хотите подключаться к облаку не только через локальную сеть, но и через интернет, то купите статический ip-адрес у своего интернет-провайдера и настройте роутер.

После того, как Nextcloud Server настроен, к нему можно подключаться различными способами, например, через браузер, но я обычно пользуюсь мобильным приложением для Android: https://play.google.com/store/apps/details?id=com.nextcloud.client&hl=ru Вот так выглядит загрузка файлов с моего телефона в облако:

Рекомендую ознакомиться с руководством пользователя на официальном сайте Nextcloud: https://docs.nextcloud.com/server/11/user_manual/

Также, мы постоянно обновляем информацию об образе на странице wiki: https://cusdeb.com/w/Nextcloud_на_Raspberry_Pi/ru

Пишите в комментариях или на почту denismosolov@cusdeb.com если что-то не получается, я постараюсь оперативно помочь.

Денис Мосолов,разработчик https://cusdeb.com

Raspberry Pi загружает операционные системы со сменных карт памяти SD/microSD (в зависимости от модели), поэтому можно держать разные операционные системы на разных картах памяти, вставляя карту памяти с нужной операционной системой, когда это потребуется. Инструмент, который нахывается BerryBoot позволяет сократить количество карт с операционными системами, предоставляя возможность загрузки множества операционных систем с одной карты памяти. На одну карту памяти ёмкостью 32Gb можно записать множество полезных дистрибутивов.

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

Что нам потребуется

• Raspberry Pi
• Карта памяти microSD на 32 или 64Gb
• Источник питания и экран
• Компьютер или ноутбук для записи файлов на карту памяти
• Кардридер

Шаг 1.
Скачиваем BerryBoot и готовим карту памяти
BerryBoot для старых моделей Raspberry Pi (младше Raspberry Pi 2)
Berry Boot для 4-ядерных моделей Raspberry Pi (2,3)

Скачайте zip архив по указанным выше ссылкам и вставьте кардридер с картой памяти в компьютер/ноутбук. Карту памяти нужно отформатировать в файловую систему FAT32. Далее распакуйте скаченный архив на карту памяти, а затем вставьте в Raspberry Pi. Во время первой загрузки BerryBoot запустит мастер для дальнейшей настройки.

Предыстория.

Нельзя сказать, что идея компактного беспроводного сервера с функциями хранения пользовательских файлов возникла и воплотилась в проекте τAURUS. В настоящее время на IT рынке присутствуют как беспроводные накопители типа Voyager Air, MobileLite, Wireless Air Bank, Air Drive, Connect Wireless Flash Drive, Wireless Plus, так и полноценные беспроводные и компактные NAS серверы типа Seagate STCR3000, Western Digital, My Cloud Synology DS115j, Corsair Voyager Air Home.

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

На базе такого решения профессор школы культуры, образования и человеческого развития Штейнгардт в Нью-Йоркском университете Дэвид Дартс (David Darts) сконфигурировал свое детище PirateBox. Сутью проекта Дэвида является наделение Raspberry Pi функциями автономного узла хранения и раздачи контента всем, кто имеет возможность подключиться к нему посредством Wi-Fi сети образованной самой Raspberry. Популяризация его идеи сразу вышла за пределы информационного ресурса Дэвида и оставила отпечаток во многих СМИ, в т.ч. в русскоязычном выпуске журнала Linux Format за 2016 год (статья «PirateBox на Pi»).

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

Нам бы также только лучше. Под таким девизом были предприняты попытки модернизации PirateBox, которые по разным причинам не привели к каким либо значимым результатам, после чего и было принято решение разработки нового проекта без оглядки на PirateBox.

Идея.

А что собственно не устраивало в PirateBox?

Ключевыми минусами этого проекта является:

• собственный web интерфейс с отсутствием удобоваримого файлового менеджера наделенного функциями «предосмотра», фильтров и критериев;

• невозможность дистанционного управления файлами в собственном хранилище (данная возможность реализована только посредством использования команды ssh или непосредственным редактированием содержимого USB-flash носителя);

• невозможность управления и настройки сервера посредством web-интерфейса;

• отсутствие поддержки ряда стандартов мультимедиа и сетевых стандартов;

• отсутствие автоматической загрузки web-интерфейса при первом подключении (функция реализована только методом перенаправления в браузере);

• отсутствие поддержки работы с мультимедиа файлами «на лету»;

• отсутствие распределения прав доступа, ну и других «плюшек», без которых сложно наладить комфортную работу с файлохранилищем.

Более того, не хватало еще одного – возможности удобного размещения собственных web-страниц для последующего мультиплатформенного тестирования и отладки где бы то ни было.

Все вышеперечисленные минусы должен был убить проект τAURUS.

Суть.

Итак, τAURUS – это автономное беспроводное портативное облачное решение, построенное на операционной системе Raspbian (Linux, Debian). τAURUS можно считать small server с

внешним USB 2.0 накопителем, аккумулятором до 4000 mAh и собственным многофункциональным интерфейсом.

Фактически мы хотели получить некое подобие NAS-сервера стоимостью в районе 40€ без учета стоимости flash накопителя USB (стоимость которого варьируется от 8€ за 16 Гб до 45€ за 128 Гб, накопители с размером памяти превышающем 128 Гб не рассматривались по причине резкого увеличения их стоимости) и стоимости microSD карты объемом 16 Гб (5€). Итоговая стоимость готового решения варьируется от 53€ до 90€.

Анализ существующих NAS-серверов представленных на рынке показал наличие единичных портативных экземпляров и стоимостью более 150€, такое стоимостное преимущество было еще одним толчком для развития проекта τAURUS.

Не будем скрывать, конкуренцию производителям NAS накопителей с объемом памяти от 512 Гб создать трудно, по одной простой причине – коммерческие твердотельные накопители с большим объемом памяти стоят достаточно серьёзных денег (от 160€), более того наличие USB 2.0 и средней скорости обмена технически проигрывают совершенным коммерческим решениям типа My Passport Wireless Pro Wi-Fi. Отчасти решением этой проблемы может стать применение SATA накопителей, что конечно повлияет на габариты и время работы τAURUS. Да и

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

Постановка задач.

• Конференции, деловые встречи и учебные классы - мгновенная многопользовательская организация хранения и раздачи электронных материалов.
• Потоковый просмотр мультимедиа - мультиплатформенный просмотр мультимедиа в любом удобном месте без привязки к наличию интернета.
• Удобное хранение - использование беспроводной сети и встроенного web-интерфейса для передачи, получения и хранения ваших файлов.
• Легкий доступ - сервер сам позаботится о загрузке web-интерфейса как только вы подключитесь к нему по беспроводной сети
• Мультиплатформенность - поддержка любых устройств с возможностями работы посредством беспроводной связи.
• Портативность - размер чуть больше кредитной карты и толщиной в два пальца, весом не более 150 г. с возможностью автономной работы до 7 часов.
• Поддержка популярных стандартов мультимедиа, сетевых протоколов и продуктов.
• Поддержка функций - "предосмотра" популярных мультимедиа файлов, установки фильтров и других "плюшек", без которых невозможно представить удобную работу с хранилищем фалов.
• Многопользовательность - создание и распределение прав доступа для пользователей.
• Легкая управляемость и настройка - "дружелюбный" web-интерфейс управления сервером и файлового менеджера.
• Доступность для частного использования - лицензии используемых программных решений предоставляют свободу действий и бесплатность для частного использования.
• Дополнительно поставлены задачи - разработка и изготовление корпуса с обеспечением защиты класса IP67, увеличение емкости аккумулятора, использование устройства в качестве PowerBank, разработка и внедрение собственных решений аналогичных продуктам Ajenti и FileRun, повышение скорости и дальности действия Wi-Fi сети, обеспечение резервирования и шифрования данных пользователей. Более того, возможно у τAURUS появится собственный сенсорный экран и полноценная светодиодная индикация.

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

1 шаг. Включение. После выполнения нашей инструкции по конфигурированию сервера подаем питание на Raspberry Pi 3 и ждем примерно 15 с пока станет доступной Wi-Fi сеть «MyCloud».

2 шаг. Подключение. Подключаемся к точке доступа «MyCloud», пароль (по умолчанию) вводить не нужно, сеть имеет открытый доступ. После подключения на вашем смартфоне автоматически появляется стартовая страница MyCloud.pi, аналогично произойдет при открытии браузера на вашем ноутбуке или компьютере.

По умолчанию загрузится интерфейс FileRun, однако если на используемой flash карте (заранее отформатированной с меткой SERVER) разместить по пути «www/html/» ваш web проект, то при загрузке будет подхвачен именно ваш index.html/php файл. Используя адрес «mycloud.pi:8000» мы перейдем на страницу доступа панели управления сервером Ajenti.Введя пароли доступа мы попадаем на вашу учетную запись менеджера FileRun или панели управления сервером Ajenti.

3 шаг. Работа. После прохождения авторизации мы получаем самое вкусное.

В случае с FileRun мы получаем PHP файловый менеджер с поддержкой русского языка для совместного использования файлов, которое позволяет организовывать, просматривать и редактировать файлы. FileRun можно использовать для хранения и просмотра документов, фотографий, музыки и других файлов.

Весь багаж возможностей FileRun вы можете оценить на сайте http://www.filerun.com.

В случае с Ajenti мы получаем мощный инструмент управления сервером с понятным и красивым интерфейсом, который, как и FileRun обладает поддержкой русского языка. Более подробно на http://ajenti.org.

Примечания

tAURUS - Название собрано из нескольких символических кубиков: τ – 19 буква греческого алфавита, часто обозначающая время релаксации, τAU – полное название все той же самой τ, rus – намекает на страну разработчика, ну и полное сочетание τAURUS - относит к астрономии древнего Вавилона к знаку зодиака тельцу, в год которого родился основатель проекта

PirateBox – устройство на платформе Raspberry PI для беспроводного обмена файлами с функциями чата и форума

Испытания

Мы пока только планируем провести ряд полноценных тестов на скорость, длительность работы при различной загрузке, температурные тесты и т.п.. На данный момент скорость загрузки файлов на tAURUS достигает 3,5 Мб/с, а чтения 1 Мб/с (что конечно пока достаточно мало). Предварительный анализ показал неутешительную работу интегрированного в Raspberry Pi 3 Wi-Fi модуля, переход на внешний USB Wi-Fi адаптер надеемся позволит улучшить картину.

Тесты на скорость обмена данными с использованием LAN интерфейса показали значения 10 – 11 Мб\с на запись и 6 – 10 Мб\с на чтение.

Результат.

На выходе мы получили беспроводной накопитель, оптимизированный для мобильного образа жизни. Он позволяет наслаждаться всем набором мультимедиа — видео, музыкой, фотографиями и привычными вам файлами, куда бы Вы ни пошли, устраняя ограничения планшетного компьютера или смартфона по объему памяти. Он является отличным выбором для тех, кому необходимы возможности хранения и потоковой передачи данных. τAURUS не нужны проводные подключения к домашней сети. Вы, ваша семья, коллеги, деловые партнеры, студенты получают инструмент одновременного беспроводного использования хранилища с функциями полноценного сервера посредством своих гаджетов. Удобный web-интерфейс позволяеN обращаться пользователям к τAURUS без специальных знаний пользования и управления серверами. Более того, τAURUS является неплохим помощником дизайнеров, верстальщиков, тестировщиков и архитекторов web-страниц любой сложности.Полностью бесплатную инструкцию вы можете получить на ресурсах MyTaurus.ru и MyCloudBox.ru.

Планы.

Проект предлагается развивать совместно с raspberry энтузиастами на площадках MyTaurus.ru и MyCloudBox.ru.

В ближайшей перспективе запланировано проведение расширенных тестов сервера и его доработка путем применения внешнего USB Wi-Fi адаптера для увеличения радиуса и скорости работы беспроводной сети.

Приоритетные задачи - разработка и изготовление корпуса с обеспечением защиты класса IP67, увеличение емкости аккумулятора, использование устройства в качестве PowerBank, разработка и внедрение собственных решений аналогичных продуктам Ajenti и FileRun, обеспечение резервирования и шифрования данных пользователей. Более того, возможно у τAURUS появится собственный сенсорный экран и полноценная светодиодная индикация

Этим летом я разослал больше 500 писем тем, кто кастомизирует дистрибутивы Linux для проектов на базе Raspberry Pi. Получив около 100 ответов, я выделил три самых распространенных причины для кастомизации операционной системы:

Причина первая - убрать лишнее

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

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

“Чем меньше пакетов установлено в системе, тем меньше запущенных в фоне программ и тем меньше операций записи на SD-карту”. Я никогда не задумывался об этом, но ведь действительно, уменьшение количества операций записи продлевает срок службы SD-карты. Изначально SD-карты были рассчитаны на хранение фотографий, а не на использование их в качестве хранилища корневого раздела операционной системы.

Причина вторая - упростить установку

Разработчики RetroPie, FreedomBox и других проектов с открытым исходным кодом подготавливают специальные сборки с предустановленным ПО для конечных пользователей. К примеру, раньше установка RetroPie на Raspberry Pi отнимала два часа, а сегодня, благодаря образу с предустановленным RetroPie это занимает десять минут. Чем проще процесс установки, тем больше пользователей пользуются приложением.

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

Причина третья - узнать новое

Некоторым просто нравится собирать операционные системы вручную. Они экспериментируют и таким образом каждый раз узнают для себя что-то новое: об архитектуре ARM, о ядре Linux, о debootstrap и т.д.

Теперь расскажу о трёх инструментах кастомизации ОС для Raspberry Pi, но на самом деле их намного больше.

rpi23-gen-image

https://github.com/drtyhlpr/rpi23-gen-image Консольная программа для создания образов с операционной системой Debian для Raspberry Pi 2 и Raspberry Pi 3. Принимает сотню параметров для конфигурации создаваемого образа, например:RELEASE=stretch RPI_MODEL=3 PASSWORD=12345 APT_INCLUDES=mc,vim IMAGE_NAME=myimage.img ./rpi23-gen-image.shСоздает минимальный образ myimage.img c Debian Stretch для Raspberry Pi 3 и устанавливает туда утилиты mc и vim. Пароль суперпользователя будет 12345. Полный список параметров смотрите здесь.

По умолчанию, rpi23-gen-image скачивает последнюю версию ядра Linux от разработчиков Raspberry Pi и кросскомпилирует под ARM. Разработчики предусмотрели 18 параметров для управления ядром, на случай, если стандартное поведение вам не подойдёт.

Чтобы воспользоваться скриптом нужна операционная система на базе Debian или его производных (Ubuntu, Linux Mint и пр.).

PiBakery

http://www.pibakery.org/PiBakery не создаёт образы с нуля в отличие от rpi23-gen-image, а используется для модификации уже существующих образов Raspbian. С помощью PiBakery невозможно перекомпилировать ядро, но в интуитивно-понятном графическом интерфейсе программы очень просто задать пароль суперпользователя и прописать настройки WIFI. 27 различных блоков с настройками сгруппированы на панели справа. Каждый блок это команда, которая будет выполнена после запуска операционной системы на Raspberry Pi, а поля ввода на блоках это параметры команд. Блоки объединяются в цепочки перетаскиванием из панели слева в рабочую область справа.

Операционная система последовательно выполнит команды из цепочки On First Boot(на скриншоте выше) при первом запуске, и будет выполнять команды из цепочки On Every Boot при каждой загрузке образа. Разработчик PiBakery рекомендует кастомизировать только официальные образы Raspbian.

PiBakery работает на компьютерах под управлением Windows, macOS и Linux(установка из исходников).

CusDeb

https://cusdeb.com/ru/ Онлайн конструктор образов для одноплатных компьютеров. Под капотом образы собираются с помощью rpi23-gen-image, но скоро перейдём на собственный скрипт под названием Pieman, чтобы не ограниваться Raspberry Pi, а собирать образы для других одноплатных компьютеров.

Для создания образа в CusDeb нужен только браузер. Пошаговый интерфейс предлагает выбрать операционную систему (Debian Jessie или Debian Stretch), выбрать целевое устройство (Raspberry Pi 2 или Raspberry Pi 3), выбрать нужные пакеты, создать пользователей и ещё пару настроек (часовой пояс, имя хоста и т.п.). Затем образ собирается на сервере и после сборки доступен для скачивания.

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

В продаже появилась новая модификация Raspberry Pi 4 - Raspberry Pi 4 c 8 Gb оперативной памяти по цене от 75$

Raspberry Pi 4 появилась на свет менее года назад, и за это время произошло много событий - продажи превысили 3 миллиона штук, плата пережила 2 небольших модернизации (rev.1.1, rev.1.2), уравнена в сторону удешевления стоимость моделей с 1Gb и 2Gb оперативной памяти. Совершенствовалось и программное обеспечение - уменьшено потребление тока в режиме ожидания и работы, реализована поддержкаOpenGL ES 3.1, начаты работы по интеграции драйвера Vulkan, реализована возможность загрузки по сети (PXE) и бета-версия загрузки с USB flash накопителя, исправлялись ошибки и добавлялись новые интересные функции.

Процессор BCM2711, который используется в RPi4, может обрабатывать до 16Gb оперативной памяти. Единственным препятствием для создания модификации платы с 8Gb памяти было отсутствие на рынке подходящихLPDDR4 чипов. В этом году подходящий чип был создан компанией Micron, что позволило сделать новую модификацию - Raspberry Pi 4 8Gb

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

Когда появится 64-битный Raspbian?

В настоящий момент базовая версия Raspbian Linux основана на 32-битном ядре и 32-битном пользовательском окружении. Такая архитектура без проблем позволяет множеству процессов делить между собой 8Gb оперативной памяти. Единственным ограничением является то, что ни один процесс не может единолично занимать больше 3Gb оперативной памяти. Этого вполне достаточно даже для браузера Chrome, т.к каждая новая вкладка запускается в отдельном процессе.

Пользователям, которым требуется возможность отдачи 8Gb оперативной памяти одному процессу нужна 64-битная ОС. Для Raspberry Pi существуют 64-битные образы Linux дистрибутивов Ubuntu и Gentoo

Разработчики Raspberry Pi также выпустили 64-битную бета-версию своей операционной системы (для моделей 3 и 4), скачать её можно по этой ссылкеТакже официальная операционная система сменила своё название с Raspbian на Raspberry Pi OS

Технология LoRa (англ. Long Range - дальний диапазон) набирает популярность в сфере IoT, подключенных автомобилей, M2M телематики и т.д. Благодаря возможности передавать данные на большое расстояние с минимальным энергопотреблением разработчики предпочитают использовать LoRa для приёма/передачи данных от устройств, питаемых от батарей.

В этой статье мы рассмотрим использование LoRa модуля SX1278/SX1276 (дальность передачи данных несколько километров) c Raspberry Pi для общения с другим устройством - Arduino с таким же модулем LoRa - SX1278. На практике это можно использовать следующим образом - Arduino выступает как сервер, собирающий данные от множества датчиков и передающий их на удалённый Raspberry Pi, выступающий в роли клиента, принимающего данные и загружающего их в облако через Интернет-соединение. Итак, поехали!

Подключение LoRa модуля SX1278 к Raspberry Pi

SX1278 16ти контактный модуль, взаимодействует с Raspberry Pi по SPI интерфейсу (логика 3.3V), поэтому подключать его можно напрямую к SPI-пинам GPIO

Raspberry Pi          SX1278 
3.3V      <-->   3.3V
Ground    <-->   Ground
GPIO 10   <-->   MOSI
GPIO 9	  <-->   MISO
GPIO 11	  <-->   SCK
GPIO 8	  <-->   Nss / Enable
GPIO 4	  <-->   DIO 0
GPIO 17   <-->   DIO 1
GPIO 18	  <-->   DIO 2
GPIO 27	  <-->   DIO 3
GPIO 22	  <-->   RST

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

Библиотека PyLora

Существует множество python библиотек для работы с LoRa модулями. Чаще всего Raspberry Pi используется в базовых станций LoRaWan для получения данных от множества LoRa устройств и последующей отправки этих данных на облачный сервер. Мы же пока рассмотрим простой P2P обмен данными при помощи Python пакета PyLora.

Подготовка Raspberry Pi

Как уже было сказано выше, взаимодействие между LoRa модулем SX1298 и Raspberry Pi происходит через SPI интерфейс, поэтому первым делом запустим из консоли sudo raspi-config и в появившемся окне выберем 5 пункт - Interfacing Options, а затем пункт "SPI enable" для включения SPI интерфейса.

Далее установим Python библиотеку для работы с GPIO Raspberry Pi

pip install RPi.GPIO

библиотеку для работы с SPI spidev

pip install spidev

и собственно пакет pyLoRa

pip install pyLoRa
PyLora также поддерживает зашифрованные соединения, но их мы рассмотрим в следующих статьях.

Программируем Raspberry Pi

В P2P LoRa соединениях модуль, передающий данные называется сервером, а принимающий - клиентом. Arduino c датчиком будет передавать полезные данные (сервер), а Raspberry Pi (клиент) - принимать.

Сама по себе программа очень простая - мы должны настроить SX1278 для работы на частоте 433Мгц и затем "слушать" эфир для приёма входящих пакетов. Если что-то приходит, выводим значение в терминал.

Подключаем необходимые библиотеки:

from time import sleep
from SX127x.LoRa import *
from SX127x.board_config import BOARD

Далее создадим класс LoRaRcvCont() с тремя методами.

Так как нам требуется только работа Raspberry Pi в качестве клиента, то в классе определены только методы init, start и rx_done

Метод set_pa_config задаёт режим работы модуля. В нашем случае инициализируем модуль для работы на частоте 433МГц с пропускной способностью 125КГц

from time import sleep
from SX127x.LoRa import *
from SX127x.board_config import BOARD

BOARD.setup()

class LoRaRcvCont(LoRa):
    def __init__(self, verbose=False):
        super(LoRaRcvCont, self).__init__(verbose)
        self.set_mode(MODE.SLEEP)
        self.set_dio_mapping([0] * 6)

    def start(self):
        self.reset_ptr_rx()
        self.set_mode(MODE.RXCONT)
        while True:
            sleep(.5)
            rssi_value = self.get_rssi_value()
            status = self.get_modem_status()
            sys.stdout.flush()
            
    def on_rx_done(self):
        print("\nReceived: ")
        self.clear_irq_flags(RxDone=1)
        payload = self.read_payload(nocheck=True)
        print(bytes(payload).decode("utf-8",'ignore'))
        self.set_mode(MODE.SLEEP)
        self.reset_ptr_rx()
        self.set_mode(MODE.RXCONT) 

lora = LoRaRcvCont(verbose=False)
lora.set_mode(MODE.STDBY)

#Medium Range  Defaults after init are 434.0MHz, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on 13 dBm
lora.set_pa_config(pa_select=1)
try:
    lora.start()
except KeyboardInterrupt:
    sys.stdout.flush()
    print("")
    sys.stderr.write("KeyboardInterrupt\n")
finally:
    sys.stdout.flush()
    print("")
    lora.set_mode(MODE.SLEEP)
    BOARD.teardown()

В функции start происходит настройка модуля как постоянного получателя данных (режим RXCONT), а также постоянный мониторинг (каждые полсекунды) уровня мощности принимаемого сигнала RSSI и статуса. RSSI измеряется вdBm и является отрицательной величиной. Минимальное значение -120 dBm.

Функция on_rx_done выполняется после приёма входящего пакета данных. После установки флага RxDone в переменную payload помещается из Rx-буффера полученное значение, затем конвертируем значение этой переменной в utf-8 и выводим в терминал. Возвращаем модуль в спящий режим до приёма следующего значения.

Также в программе реализовано завершение при нажатии на кнопки клавиатуры.

Подключение SX1278 к Arduino

SX1278                Arduino UNO 
3.3V	  <-->   3.3V
Gnd	  <-->   Gnd
En/Nss	  <-->   D10
G0/DIO0	  <-->   D2
SCK	  <-->   D13
MISO	  <-->   D12
MOSI	  <-->   D11
RST	  <-->   D9

Программируем Arduino

Первым делом нужно установит в Arduino IDE библиотеку Radiohead от AirSpayce. Скачать её можно отсюда -https://github.com/PaulStoffregen/RadioHead

Программа для Arduino будет отправлять тестовые пакеты с численными значениями от 0 до 9.

Подключаем SPI библиотеку и RH_RF95 для осуществления LoRa связи. Затем прописываем, к каким контактам Arduino подключены линии CS, RST, INT модуля SX1278 и устанавливаем частоту работы модуля (434Мгц)

В функции setup перезагружаем LoRa модуль, устанавливая низкий уровень на контакте сброса (RST) на 10 миллисекунд. Инициализируем SX1278 функцией rf95.init() . Затем устанавливаем частоту и мощность передатчика (чем больше, тем дальше максимальное расстояние передачи, но и выше энергопотребление)

#include <SPI.h> //подключаем библиотеку SPI  
#include <RH_RF95.h> // подключаем библиотеку RF95  

#define RFM95_CS 10 
#define RFM95_RST 9
#define RFM95_INT 2 

#define RF95_FREQ 434.0

RH_RF95 rf95(RFM95_CS, RFM95_INT);

void setup() 
{

  Serial.begin(9600);  
// Перезагрузка LoRa модуля 
  pinMode(RFM95_RST, OUTPUT); 
  digitalWrite(RFM95_RST, LOW);
  delay(10);
  digitalWrite(RFM95_RST, HIGH);
  delay(10);

//Инициализация LoRa модуля 
  while (!rf95.init()) {
    Serial.println("LoRa radio init failed");
    while (1);
  } 
 //Устанавливаем частоту 434.0MHz
  if (!rf95.setFrequency(RF95_FREQ)) {
    Serial.println("setFrequency failed");
    while (1);
  }

  rf95.setTxPower(18); //устанавливаем мощность передатчика
}
char value = 48;
void loop()
{
  Serial.print("Send: ");
  char radiopacket[1] = {char(value)};
  rf95.send((uint8_t *)radiopacket, 1); 
  delay(1000);
  value++;
  if (value > '9')
  value = 48;
}

В бесконечном цикле главной функции отсылаем пакеты с данными методом rf95.send() . Данные могут быть любые, например, показания датчиков или пользовательские команды. В нашем примере просто отсылаются символьные значения от 0 до 9 с интервалом в 1 секунду.

Проверка работы

Загружаем программу в Arduino, включаем Raspberry Pi и запускаем на ней Python скрипт.

Если всё сделано верно, то в терминале должны начать выводиться принимаемые значения

В следующей статье рассмотрим построение базовой станции LoRaWan на основе Raspberry Pi и LoRa модуля SX1301/SX1308