Арендовать мощные VPS под ресурсоемкие задачи в текущих реалиях выходит неоправданно дорого. При этом дома у меня уже был выделенный неттоп (мини-ПК) с 16 ГБ оперативной памяти на базе энергоэффективного процессора Intel N95.

Пройдя путь от простых Bash-скриптов и сторонних туннелей до полностью автоматизированной инфраструктуры, я создал проект ServeHub-2. В этой статье я подробно разберу, как эволюционировала сеть проекта, почему декларативный подход победил императивный и с какими неочевидными багами пришлось столкнуться в процессе автоматизации.

История настройки сетевой архитектуры

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

В самом начале проекта я еще не думал о VPN как о способе пробития NAT и основе, на которой будет строиться вся система. Первое, к чему я пришел — сервис Tuna. Если кратко, это аналог Cloudflare Tunnel за условные 300 рублей. У него очень приятный веб-интерфейс и невероятно простая настройка. Однако для полноценной независимой архитектуры он не подошел по двум причинам:

• Сервера Tuna находятся вне контроля пользователя.
• На удаленном сервере нельзя развернуть свои сопутствующие сервисы.

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

Вот пример конфига для tuna (все максимально просто, создаем контейнеры для ssh туннеля, чтобы был доступ ssh, а также основной http туннель с привязкой к nginx или любому другому прокси если такой есть):

В поисках гибкости: тесты Pangolin и переход к FRP

После Tuna я решил двигаться в сторону собственного контроля и попробовал Pangolin. Однако решение быстро отвалилось: для дешёвого сервера оно оказалось слишком «тяжёлым» и избыточным. Главные минусы — ощутимый оверхед по ресурсам и лишний слой принудительной веб-аутентификации перед самими сервисами. Это ломало нормальное взаимодействие с родными мобильными клиентами (вроде Element для Matrix или Bitwarden для паролей), где повторная авторизация в браузере просто не нужна.

На смену пришел FRP (Fast Reverse Proxy). Он выполнял ту же функцию проброса, но хостил я его уже на собственном арендованном VPS в режиме Layer 4 (TCP). Это дало абсолютную гибкость: внешний VPS не заглядывал внутрь пакетов и ничего не расшифровывал, а просто пересылал сырой поток домой. Кроме того, это отлично оптимизировало расходы: вместо 300 рублей за Tuna и ещё 300 рублей за отдельный VPN, я стал платить всего 500 рублей за один стойкий VPS, который мог настраивать как хочу. (к тому же можно было обойтись даже дешевле, так как VPS с 4 гб оперативки загружен всего лишь на 40%, процессор всего на 20%-40%)

FRP состоит из 2 конфигурационных файлов (один на удаленном сервере frp server, другой на локальном frp client), все также довольно просто, однако его можно использовать на разных слоях. У меня он брал трафик за стандартный TCP и передавал его на локальный сервер.

Также доп. фишка в том что основная конфигурация происходит именно в frpc, который, в свою очередь, передает часть настроек на frp на удаленном сервере.

frpc.toml:

frps.toml:

Полноценный переезд на WireGuard (AmneziaWG) и 8 часов отладки

Со временем архитектура эволюционировала в сторону полноценной VPN-сети на базе WireGuard, а точнее — его модификации AmneziaWG. Причин для этого шага было несколько:

• Безопасность: FRP всё же открывал внутренние ресурсы в публичный интернет, оставляя их доступными для сканеров портов.
• Удобство маршрутизации: Все участники сети стали равноправными узлами в одной виртуальной локальной подсети. Больше не нужно было настраивать постоянные односторонние пробросы.
• Дополнительный бонус: Поскольку удаленный VPS был куплен в Нидерландах, через этот же VPN я автоматически получил безопасный доступ ко всем зарубежным ресурсам.

Для реализации схемы на удаленном VPS был развернут контейнер wg-easy с поддержкой AmneziaWG, а на домашнем мини-ПК — клиентский контейнер Amnezia (сборка из Dockerfile с использованием amnezia-tools и модулем ядра хоста).

И именно здесь я поймал самый изнурительный баг проекта. После развертывания трафик упорно шёл только в одну сторону. Часов 8 ушло на диагностику iptables, маршрутов и чтение зарубежных форумов (что бесполезно, учитывая специфику наших блокировок). Оказалось, провайдер просто дропал обратный трафик стандартного WireGuard, так как пакеты шли без маскировки. Причина крылась в docker-compose.yml: у меня было прописано image: ghcr.io/wg-easy/wg-easy:latest. Как выяснилось, тег latest на Docker Hub намертво прилип к старой 14-й версии, а поддержка параметров AmneziaWG появилась только в ветке 15.x. Изменение тега на конкретную версию (15.3) решило проблему за секунду.

Благодаря переходу конфигурация получилась максимально простой, основные отличия от стандартной документации выделил в коде: (в основном то, на что пришлось долго рыть информацию)

Настройка Nginx

Чтобы сервисы были доступны исключительно внутри подсети VPN, я задействовал Nginx. Доступ к приложениям был жестко ограничен на уровне конфигурации — веб-сервер принимает запросы только из диапазона IP-адресов 10.8.0.0/24. Любые попытки постучаться на сервер из внешнего интернета без активного VPN-туннеля автоматически сбрасываются Nginx.

Логика распределения завязана на proxy-протоколе: Nginx на удаленном VPS выступает основным входным узлом, принимает зашифрованный трафик, заворачивает его в заголовки с реальным IP-адресом клиента и через туннель перекидывает на локальный Nginx домашнего сервера. Локальный веб-сервер уже сам расшифровывает SSL и распределяет трафик по конечным Docker-контейнерам, сохраняя реальные IP в логах безопасности.

Вставлю один кусок кода из nginx на удаленной машине для примера, так все остальное примерно похоже (конфиги использовались в виде .template):

SSL-сертификаты

Для получения валидных SSL-сертификатов я настроил работу через автоматический Certbot по challenge-валидации DNS-01 c API Webnames. Сам домен привязан к внутреннему IP-адресу 10.8.0.1. Проверка через DNS позволила выпустить единый wildcard-сертификат на весь домен и его поддомены без необходимости держать открытым 80-й порт веб-сервера наружу.

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

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

Вот настройка certbot:

История софта

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

Первый стек и оптимизация

Первыми на домашнем сервере прижились медиа-сервисы: Navidrome для стриминга музыки и Audiobookshelf для аудиокниг и подкастов. Они легковесные, имеют отличные мобильные клиенты с синхронизацией прогресса и полностью закрывают мои потребности. Позже к ним добавился Nextcloud как единое независимое облако для файлов, контактов и семейных документов.

Затем встал вопрос безопасного хранения паролей. Сначала я смотрел в сторону оригинального Bitwarden, но в итоге я выбрал Vaultwarden — альтернативный сервер на Rust, полностью совместимый с API Bitwarden. Он потребляет считанные мегабайты оперативной памяти и работает идеально. Дополнительно для удобства управления всей этой распределенной Docker-инфраструктурой в локальный стек был добавлен Portainer. (+ Portainer Agent на удаленный сервер)

Из интересных моментов, где мне пришлось немного больше возиться, чем с остальными сервисами это nextcloud настройка:

Ошибки проектирования: почему я удалил Matrix (Synapse)

Не все решения прошли проверку временем. На этапе использования Tuna и FRP я развернул сервер Matrix (Synapse) для защищенного обмена сообщениями. Мне казалось это крутой идеей, но когда я окончательно перешел на AmneziaWG, целесообразность мессенджера внутри закрытого туннеля сошла на нет.

Synapse требовал слишком много ресурсов, впустую расходовал оперативку домашнего ПК и усложнял конфиг Nginx. При этом реальной пользы для семьи он не приносил. Для критических алертов инфраструктуры и повседневного общения проще и эффективнее оказалось использовать Telegram. (плюс алертинг настроен именно через него) В итоге я полностью выпилил Synapse из стека, освободив ресурсы.

Вместо него я добавил в связку к wg-easy локальный AdGuard Home. Теперь он работает прямо внутри VPN-сети: очищает весь трафик от рекламы и трекеров на лету, кэширует DNS-запросы и не дает истории веб-серфинга улетать внешним провайдерам.

Основной проблемой с которой я столкнулся при использовании AdGuard Home, так это то что я так и не понял как заставить использовать AmneziaVPN клиент AdGuard как основной DNS, при этом AmneziaWG работает прекрасно. Как я понимаю дело в том что AmneziaWG работает намного проще на уровне ip и у него нету никаких доп фильтров, настроек и подобного, поэтому он просто берет данные из конфига.

От костылей на Bash к декларативному Ansible

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

Так я пришел к декларативному подходу и Ansible. Теперь вся конфигурация описывается в виде плейбуков и ролей, отражающих конечное желаемое состояние серверов. Конфиденциальные данные перенесены в файл secrets.yml, а хрупкие конструкции автоматизированы через шаблоны Jinja2. Проект стал идемпотентным: если шаги уже выполнены, Ansible их просто пропускает.

В итоге получилось несколько yaml файлов для стандартной настройки системы (bootstrap_os.yml) и для настройки каждого из хостов (setup_local.yml и setup_remote.yml). В итоге теперь все что нужно чтобы полностью с нуля развернуть проект - скачать Ansible, несколько других зависимостей на свой рабочий пк и запустить один manage_deploy.sh, в котором можно будет выбрать сценарий как будет вести себя Ansible и спокойно дождаться разворачивания сервисов.

Также благодаря Ansible я удобно реализовал переносимость проекта. Так как я решил не использовать тома docker, и вместо этого храню все в папках, чтобы перенести старые данные проекта нужно просто скопировать папку apps-data и положить ее в нужное место и все само заработает после повторного развертывания проекта. В Ansible выделяется отдельная пауза для этого.

Вот пример основного плейбука deploy.yml:

Тестирование мультидистрибутивности с помощью Vagrant

Проект изначально затачивался под работу на трех дистрибутивах: Ubuntu, Debian и Arch Linux. Тестировать Ansible-плейбуки прямо на рабочей локальной машине (в моем случае — EndeavourOS) слишком рискованно, а создавать виртуальные машины руками — долго и неудобно.

Решением стал Vagrant, позволяющий за пару минут развернуть чистые ОС в VirtualBox из готовых образов. Но в процессе настройки мультивендорного стенда в режиме сетевого моста (public_network) всплыли две критические проблемы:

1. Конфликт DNS: По умолчанию Vagrant создает NAT-интерфейс для управления нодой. При включении второго (публичного) интерфейса для локальной сети ломался дефолтный DNS-резолвер. Проблему пришлось решать принудительной очисткой и перезаписью файла /etc/resolv.conf через inline-скрипт автоматизации Vagrant.
2. Проблема с GRUB на Debian: В используемом базовом образе generic/debian12 конфигурация GRUB сохраняла жесткую привязку к конкретному имени диска из окружения сборщика. При повторном развертывании плейбуков на тестовом стенде это приводило к сбоям загрузчика. Чтобы автоматизировать очистку, пришлось внедрить скрипт, который на лету определяет имя системного диска через lsblk и автоматически передает правильные параметры в загрузчик через утилиту debconf-set-selections.

Вот код Vagrantfile: (в node.vm.provision происходит основное решение ошибок)

Надежная система бэкапов на базе BorgmaticДля создания резервных копий я внедрил Borgmatic (удобную надстройку над дедуплицирующим инструментом Borg Backup). Весь процесс автоматизирован с помощью связки системных юнитов borgmatic.service и borgmatic.timer. В бэкап уходят две ключевые директории: apps-data (конфигурации приложений и баз данных) и PersonalData (медиатека: музыка, книги, подкасты, файлы Nextcloud).

Развертывание системы бэкапов полностью берет на себя Ansible. Мне достаточно указать UUID внешнего жесткого диска — скрипт сам проверит его наличие в системе, примонтирует в нужную директорию, создаст зашифрованный репозиторий и настроит политику ротации (хранение 7 ежедневных, 4 еженедельных и 6 ежемесячных копий). Также в Prometheus выведен мониторинг самого репозитория .borg для отслеживания его размера и статуса успешности архивации.

Главная проблема при бэкапе работающих Docker-контейнеров — риск скопировать базу данных в «битом» или неконсистентном состоянии, если в момент создания архива в нее шла активная запись. Чтобы решить эту проблему, я задействовал механизм хуков в конфигурации Borgmatic.

Перед началом резервного копирования автоматически срабатывает команда остановки контейнеров проекта (docker-compose down), а после успешного завершения (или в случае возникновения непредвиденной ошибки) контейнеры автоматически поднимаются обратно в фоновом режиме. Для удобного просмотра архивов и быстрого восстановления файлов я развернул веб-интерфейс Borg UI.

Конфигурация borgmatic: (использую как Jinja2 шаблон, чтобы Ansible в плейбуках сам подставил переменные)

Наблюдаемость (Observability) уровня Enterprise

В последних релизах (v1.2.0 и v1.3.0) фокус проекта сместился на мониторинг и работу с логами.

Эволюция алертинга и переход на Gatus

Изначально для мониторинга доступности я смотрел на Uptime Kuma, но отказался из-за отсутствия удобной декларативной настройки через конфиги. Затем я развернул связку Blackbox Exporter и Alertmanager с уведомлениями в Matrix. Но тут крылась логическая несостыковка: весь алертинг был завязан на локальном ПК, и в случае его аппаратного отказа я бы просто лишился уведомлений.

Тогда я решил вернуть Uptime Kuma, но развернуть его на удаленном VPS в качестве внешнего «сторожа» и автоматизировать его настройку через Python-скрипт с библиотекой uptime-kuma-api. Но и тут ждали «грабли» — библиотека не обновлялась три года и намертво ломалась на свежих версиях Kuma.

В итоге идеальным решением стал Gatus. Он изначально проектировался под управление через YAML-конфиги и поддерживает отправку алертов, если сервер не отвечает. Из-за специфики фронтенда Gatus (он не умеет работать из подкаталога типа /gatus), мне пришлось перенести его и wg-easy на полноценные субдомены gatus. и wireguard.

Для Gatus получился простой конфиг:

Для мониторинга аппаратных ресурсов удаленного и локального серверов была развернута связка node-exporter + cAdvisor. Все уведомления теперь приходят мгновенно в Telegram-бота. Чтобы избежать лавины одинаковых сообщений (например, при перезагрузке хоста), в Alertmanager настроена жесткая группировка и дедупликация событий. Также добавлен экспортер для AdGuard Home, выводящий статистику заблокированных запросов в Grafana.

Централизованные логи: Loki + Grafana Alloy

В релизе v1.3.0 в стек была добавлена централизованная система сбора логов Loki. Вместо устаревшего Promtail в качестве агента сбора я применил Grafana Alloy.

Он эффективно собирает логи со всех запущенных Docker-контейнеров, парсит их и передает в Loki. Теперь вся история событий, ошибок веб-сервера Nginx или падений внутренних приложений доступна в едином интерфейсе Grafana с возможностью удобной фильтрации через LogQL, что значительно упрощает отладку.

Конфиг Loki:

Конфиг Grafana Alloy: (локальный конфиг)

Интерфейс: переход на Homepage

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

В итоге я заменил самописную страницу на полноценный комьюнити-проект Homepage. Это дало некоторую гибкость: вся панель настраивается через простые YAML-файлы и поддерживает встроенные виджеты интеграции. Пока что она простенькая, но возможно в будущем сделаю что-то более продвинутое.

Заключение

Постарался подробно рассказать о структуре проекта и как я к этому пришел, очень много я не добавил, если пост зайдет, то я обязательно более подробно пройдусь по некоторым моментам: как я настраивал Matrix и на каком моменте я решил его убрать, как собирал локальный amnezia контейнер-клиент, что нового я добавил в релизе 1.4.0 и другое.

Также я перешел с manage_deploy.sh на отдельный GUI клиент, который будет полностью автоматизировать процесс подготовки к deploy. (написан на Go Wails). Про это тоже возможно сделаю статью.

Вся кодовая база проекта, подробная документация, инструкции по развертыванию открыты и доступны для сообщества:

🔗 GitHub-репозиторий: https://github.com/canntstand/ServeHub-2

Это моя первая статья на этом сайте и в то же время первый личный проект, которому я отдал так много времени (3 месяца). Буду рад вашему фидбеку в комментариях!

Правительство США анонсировало политику, фактически запрещающую импорт новых потребительских роутеров. Но оказывается, роутер можно собрать буквально из любого компьютера. Автор оригинальной статьи использует мини-ПК на Linux в качестве домашнего роутера уже несколько лет: ни одного серьёзного сбоя, единственная замена — дешёвый mSATA-диск.

Мини-ПК, настольный компьютер, одноплатник, стоечный сервер, старый ноутбук — подойдёт всё, что запускает Linux и имеет пару USB-портов. В этой статье разберём полную настройку на Debian: от выбора железа до правил firewall.

— Роутер — это обычный компьютер с Linux, двумя сетевыми интерфейсами и несколькими пакетами.

— Для сборки хватит мини-ПК, старого ноутбука или одноплатника с USB-Ethernet-адаптером.

— Всё ПО — hostapd, dnsmasq, bridge-utils — входит в стандартные репозитории Debian.

— Настройка занимает около часа и не требует глубоких знаний сетей.

Выбор железа

Идеальный вариант — компактный пассивно охлаждаемый мини-ПК. Однако подойдёт практически что угодно. Главное условие: два Ethernet-интерфейса. Если у устройства только один — выручит обычный USB-Ethernet-адаптер. Это чуть менее надёжно, чем встроенный порт, но для домашней сети вполне достаточно.

Пример из практики автора: мини-ПК на Celeron 3205U (два ядра, 1,5 ГГц) без проблем выдаёт 820–850 Мбит/с по кабелю и около 300 Мбит/с по Wi-Fi. Даже такой скромный процессор с запасом тянет трафик целого дома или небольшого офиса.

Для совсем экстремальных случаев: в 2016 году автор собрал роутер из ThinkPad T60 (подобранного на мусорке), ExpressCard-PCIe-моста, безымянной Ethernet-карты и свитча Cisco 2960 за $10. Выглядело как куча хлама — но работало.

Архитектура сети

После настройки интерфейсы распределяются так: eth0 — WAN (внешняя сеть, интернет), eth1 — проводная LAN, wlan0 — Wi-Fi LAN.

eth1 и wlan0 объединяются в мост br0 — проводные и беспроводные устройства оказываются в одной сети. Нужно больше портов? Просто добавьте USB-Ethernet-адаптеры и включите их в мост.

Используемое ПО: hostapd для Wi-Fi точки доступа, dnsmasq для DHCP и DNS, bridge-utils для объединения портов. Статья покрывает только IPv4 — IPv6 в домашней LAN по-прежнему создаёт больше проблем, чем решает.

Установка Debian

Установка стандартная, но стоит учесть несколько нюансов:

• В BIOS отключить PXE-загрузку по сети
• Выставить минимальную частоту процессора, но отключить power management для USB и PCI-устройств
• Включить опцию «Restore after AC Power Loss» — роутер должен запускаться сам после отключения питания
• Если устройство не стартует без монитора — вставить HDMI-заглушку (dummy dongle)
• Включить репозиторий non-free-firmware — большинство Wi-Fi-адаптеров без него не работает

После базовой установки доставьте прошивку для своего Wi-Fi-адаптера. Для Intel:

Для Realtek:

Для совсем старого железа (Atheros и подобные):

Установка пакетов

Три пакета — это всё необходимое. Итого около 250 пакетов на системе:

Переименование сетевых интерфейсов

В современном Linux интерфейсы называются по физическому расположению: например, enp0s31f6. Чтобы не запутаться, зафиксируем привычные имена eth0, eth1 через systemd.network.

Для каждого сетевого интерфейса создайте файл /etc/systemd/network/10-persistent-ethX.link (где X — номер интерфейса):

MAC-адреса своих интерфейсов узнайте командой ip link show. Создайте по одному такому файлу для каждого Ethernet-порта.

Настройка Wi-Fi через hostapd

USB-Wi-Fi-адаптер будет работать как точка доступа. Это не заменит выделенный AP-девайс по качеству сигнала, но в небольшом помещении работает вполне приемлемо. Если Wi-Fi критичен — лучше подключить к LAN-порту старый роутер в режиме точки доступа.

Создайте конфиг /etc/hostapd/hostapd.conf:

По умолчанию служба hostapd замаскирована (masked). Размаскируйте и запустите:

Настройка сетевых интерфейсов

eth0 — внешний интерфейс (WAN, получает IP по DHCP от провайдера). br0 — внутренний мост с фиксированным адресом. Обратите внимание: у LAN-интерфейса нет шлюза по умолчанию.

Файл /etc/network/interfaces:

После этого перезагрузите устройство. Если сеть не поднялась, проверьте ошибки:

При успешной настройке вывод команды должен быть таким:

IP Forwarding

Без IP forwarding роутер не будет пробрасывать пакеты между интерфейсами. Создайте файл /etc/sysctl.d/10-forward.conf:

Примените изменения:

Настройка firewall через nftables

Правила firewall и NAT управляются через nftables — современную замену iptables. Конфиг /etc/nftables.conf:

Этот конфиг делает три вещи: включает NAT (masquerade), блокирует весь входящий трафик извне и разрешает роутеру работать как DNS, DHCP и SSH-сервер для локальной сети.

Включите nftables при загрузке:

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

В отличие от устаревшего iptables, nftables позволяет перезагружать правила без разрыва соединений:

DHCP и DNS через dnsmasq

dnsmasq — компактная альтернатива паре isc-dhcp-server + bind9. Конфиг элементарный. Создайте /etc/dnsmasq.conf:

DHCP-диапазон: 192.168.1.50 — 192.168.1.250, аренда на 6 часов. Адреса 192.168.1.2 — 192.168.1.49 остаются для статических назначений.

Бонус: последовательный порт (Serial/UART)

Если на устройстве есть последовательный порт — настройте UART-консоль. В enterprise-оборудовании это стандарт, но для домашнего роутера тоже удобно: управляйте без монитора и клавиатуры через USB-UART-адаптер.

В файле /etc/default/grub добавьте или замените строки:

Активируйте getty на последовательном порту, обновите GRUB и перезагрузите:

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

После настройки перезагрузите устройство дважды — убедитесь, что всё поднимается стабильно. Проверьте состояние firewall и счётчики трафика:

Ненулевые счётчики в цепочках forward и postrouting означают, что трафик проходит через роутер. Проверьте DHCP-аренды:

Что ещё можно добавить

Базовая конфигурация работает как полноценный домашний роутер. При желании её можно расширить:

• VLAN и сегментация сети
• VPN (удалённый доступ и site-to-site туннели)
• Динамическая маршрутизация: IGP, BGP
• IDS/IPS (обнаружение и предотвращение вторжений)
• Логирование отдельных правил и flow logs
• Проброс портов в DMZ
• IPv6
• Мониторинг в реальном времени
• Фильтрация и блокировка трафика

Важное правило: не устанавливайте много дополнительного ПО прямо на роутер. Лучше выделить отдельную машину в DMZ или VLAN и пробрасывать на неё трафик. Роутер должен оставаться простым и надёжным.

Итого

Роутер — это просто компьютер с Linux, двумя сетевыми интерфейсами и тремя пакетами. Ничего магического в потребительских роутерах нет: они тоже работают под управлением Linux (обычно урезанным), просто с удобным веб-интерфейсом поверх.

Мини-ПК на базе Celeron или Atom стоит $30–60 на вторичном рынке, потребляет 5–10 Вт и работает годами без обслуживания. Это надёжнее, гибче и дешевле большинства потребительских роутеров — а заодно отличный способ разобраться, как на самом деле работает сеть.

По данным нового исследования Common Sense Media, более 70% подростков в США используют ИИ-компаньонов, причем треть из них — ежедневно или несколько раз в неделю.

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

Подростки начинают воспринимать ИИ-компаньонов как родителей, друзей и… романтических партнеров

«Ты всегда прав»: как ИИ стал идеальным собеседником

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

• 31% подростков считают, что ИИ-компаньоны «так же хороши или даже лучше» в общении, чем реальные друзья
• 33% обсуждали с ИИ серьезные личные темы, вместо того чтобы пойти к живому человеку
• 11% используют чат-ботов, чтобы «набраться смелости» — постоять за себя или признаться в чувствах

Виртуальные «пары»: от комплиментов до расставаний

Многие подростки не просто разговаривают с ботами — они «встречаются» с ними. Пользователи платформ вроде Replika и Character.AI настраивают ИИ-компаньонов под себя: выбирают внешность, характер, стиль общения.

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

• Писал девушке любовные сообщения, сгенерированные ИИ
• Поручил боту написать текст расставания, завершив двухлетние отношения
• И продолжил «эмоциональное общение» — но уже только с ИИ

Это было почти дистопично… Как будто мы позволяем машинам заменять реальные чувства

Почему это тревожит исследователей

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

Если подростки развивают эмпатию и самооценку в среде, где их всегда поддерживают и никогда не критикуют — в реальном мире они могут растеряться

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

Больше новостей в нашем тг-канале Представляешь

Идея проста: вместо утилизации или бессмысленного хранения в ящиках, устройства получают вторую жизнь как вычислительные узлы. Учитывая, что ежегодно производится более 1,2 млрд новых телефонов, а средний срок их использования — 2–3 года, такая схема позволяет радикально снизить нагрузку на природу. Тем более, что большая часть техники остаётся работоспособной даже после списания.

Прототип ученых стоил всего 725 рублей по текущему курсу. Смартфоны были лишены аккумуляторов и подключены к внешнему питанию, чтобы исключить утечки вредных веществ. Затем их объединили в пластиковом корпусе, напечатанном на 3D-принтере. Получившийся кластер успешно справился с реальными задачами — например, автономным мониторингом морской фауны под водой. Раньше для таких операций требовались водолазы и последующая ручная обработка видео. Теперь всё происходит прямо в толще воды, в реальном времени.

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

Компания представила Raspberry Pi Pico 2 W — микроконтроллер с поддержкой Wi-Fi и Bluetooth.

Устройство построено на базе нового чипа RP2350 и стоит всего $7. Это идеальное решение для проектов, связанных с Интернетом вещей (IoT).

RP2350: мощь и доступность

Чип RP2350 стал развитием успешного RP2040, который дебютировал в 2021 году и быстро завоевал популярность у разработчиков.

Новый процессор предлагает более высокую производительность, улучшенное энергопотребление и встроенную защиту на основе технологии TrustZone от ARM.

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

RP2350 впервые появился этим летом на плате Pico 2, а также в ряде продуктов партнёров Raspberry Pi. Теперь его возможности доступны в новой беспроводной версии.

IoT на новой высоте

Raspberry Pi Pico 2 W создан для проектов, где важны подключение к облаку и взаимодействие с физическим миром.

Устройство оснащено модемом CYW43439 от Infineon, который поддерживает Wi-Fi 2.4 ГГц и Bluetooth 5.2. Для работы с устройством доступны библиотеки на языках C и MicroPython.

Благодаря компактному форм-фактору и совместимости с макетными платами, Pico 2 W идеально подходит для прототипирования.

А новый радиомодуль RM2, который будет использоваться в профессиональных продуктах, даёт возможность масштабировать решения, разработанные на этой платформе.

Новые возможности для DIY-сообщества

Pico 2 W — это не только инструмент для профессионалов, но и мощная утилита для любителей электроники.

Raspberry Pi продолжает работать над новыми версиями линейки Pico 2 — так, следующая волна обновлений ожидается уже в 2025 году.

HumanPlus (так назвали новинку) может научиться боксировать, играть на пианино, отбивать мячик для пинг-понга и печатать, просто повторяя за человеком.

Упрощенный метод обучения

Метод обучения, выбранный для HumanPlus, значительно проще, чем у популярных моделей, таких как Figure 01 или робот Eve от 1X, которые работают на основе понимания естественного языка.

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

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

DIY-подход

В отличие от своих собратьев, таких как Atlas от Boston Dynamics или Optimus от Tesla, HumanPlus представляет собой больше вариант «сделай сам».

Цена всех материалов для сборки HumanPlus превышает $100 000, если следовать точным спецификациям исследователей.

Робот построен на базе Unitree H1, с руками от Inspire-Robots, запястий от Robotis и веб-камеры Razer. Рост HumanPlus — 175 см. Число степеней свободы — 33.

Открытый исходный код

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

Один из исследователей, Цзипэн Фу, отметил, что оборудование для удаленного управления HumanPlus стоит всего $50, что значительно дешевле по сравнению с популярным вариантом использования гарнитуры Quest.

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

Процесс создания начался с изучения основ GPU и закончился полноценным чипом, спроектированным в Verilog и проверенным с помощью программного обеспечения OpenLane EDA.

Адам описал весь процесс в соответствующем Twitter-треде, предоставив подробное описание каждого этапа разработки.

Проект был ориентирован на создание GPU для общих параллельных вычислений (GPGPU), что предусмотрело корректировку архитектуры инструкций, включающую всего 11 команд.

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

Несмотря на начальный успех, создание GPU в Verilog принесло ряд сложностей, связанных с памятью и реализацией расписания задач. Советы известного программиста Джорджа Хотца помогли Адаму преодолеть эти препятствия. Третья переработка кода решила проблемы с расписанием выполнения вычислений в вычислительных ядрах.

В итоге Адам добился работоспособности своего GPU, доказав это видео с демонстрацией работы ядра матричного сложения:

Хотя работа Адама не претендует на звание лучшей видеокарты, она отражает важность инноваций и DIY-подхода в технологической сфере.

По словам инженера, он насладился созданием визуализации своего дизайна GPU и с нетерпением ждет получения готового чипа.

Мало выбрать подходящий принтер или МФУ для дома или офиса. Нужно еще помнить, что периодически придется менять картридж и фотобарабан. Неправильно или не вовремя выполненная работа может привести к поломке всего устройства. Когда можно заправлять картридж, а когда лучше поменять, сколько работает фотобарабан, и почему в старые модели можно засыпать совместимый тонер, а в новые не стоит, рассказывает руководитель отдела продаж в странах СНГ российского представительства компании Pantum Денис Милентьев.

Когда и зачем придумали перезаправлять картридж

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

Откуда вообще появилась идея о том, что картриджи можно перезаправлять? Все дело в том, что на большинстве бюджетных устройств картридж совмещен с фотобарабаном, ресурс которого в разы выше, чем у зарядки картриджа. И вместо того, чтобы выбрасывать довольно дорогой расходник, умельцы нашли выход: в картридже просверлить пару отверстий – через одно высыпать то, что осталось от прежнего тонера, в другой – засыпать новый. Однако, сама процедура довольно сложна и опасна для здоровья. Порошок очень мелкий, попадает в любую щель, а заодно и органы дыхания, и может негативно отразиться на состоянии человека. Если же работа выполнена не очень качественно, порошок может начать высыпаться внутрь принтера и вывести из строя само устройство. Кроме того, если новый тонер не совместим с конкретной моделью принтера, это тоже может «похоронить» технику раньше времени. И это одна из основных причин, по которым производитель снимал с гарантии принтеры с перезаправленными тонерами.

Сегодня на рынке представлено довольно много производителей тонеров для принтеров практически всех основных марок. Есть относительно дорогая продукция, которую можно использовать довольно уверенно. Особенно это касается многих устаревших моделей, которые еще нормально работают, а оригинальных картриджей для них уже не производят. Рецептура для этих устройств подобрана хорошо и зарекомендовала себя на протяжении долгого времени. Другое дело, когда речь идет об откровенном фальсификате – подделках и просто дешевом тонере сомнительного качества. Такой тонер с большой степенью вероятности быстро выведет из строя печку принтера, и дешевле будет просто заменить устройство. Нужно подчеркнуть, что, как правило, подобная модель эксплуатации характерна для дешевых черно-белых принтеров формата А4. Бывает, пользователь заранее готов к тому, что покупает бюджетный аппарат, несколько раз перезаправляет его и просто меняет – при определенных условиях это дешевле, чем покупать оригинальный картридж, который зачастую стоит как половина принтера.

«Убийственная экономия»

Если говорить о современных моделях, то они меняются быстрее, чем производители совместимых тонеров успевают подобрать рецептуру к актуальным устройствам, и здесь рисковать не стоит. Правда, отдельные вендоры начали разрабатывать заправляемые картриджи, оснащенные специальными технологическими отверстиями для замены тонера. Сам тонер поставляется в формате специального комплекта для дозаправки. Из мировых лидеров такой комплект для нескольких линеек разработал Pantum, есть информация, что работы в этом направлении ведут другие “гранды”, такие как Xerox.

Где точно не стоит заниматься заменой тонера? Вряд ли нужно искать «совместимку» для цветных принтеров, не важно, струйных или цветных. В отличие от черно-белых устройств, где требуется только четко печатать тексты, в цветных неоригинальная замена практически гарантирует неверную цветопередачу, а значит можно забыть о красивых фотографиях и ярких картинках. А принтеры с форматом А3, которые стоят сотни тысяч рублей, точно не стоит «кормить» неоригинальными чернилами, ремонт или замена будут стоить гораздо дороже расходников – экономить здесь явно не нужно. Впрочем, и фотобарабан в таких принтерах, как правило, размещен отдельно от картриджа, и замена априори будет дешевле, чем в тех устройствах, где картридж объединен с фотобарабаном.

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

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

Впервые перфокарты начали использовать ещё в начале XIX века. В 1804 году в Жаккардовых ткацких станках перфокарты использовали, чтобы управлять составлением узоров на тканях.

Для ЭВМ перфокарты ввели в 1928 году, и с тех пор они почти не менялись, и использовали их вплоть до 1980-х годов, пока не заменили магнитными лентами.

Несмотря на то, что перфокарты были доступны в течение 50 лет, сегодня их уже не прочитать, потому что для современных ПК нет подходящих приводов, хотя столь же устаревший Floppy-привод для дискет всё ещё можно найти в интернет-магазинах.

В этой статье мы расскажем, как собрать собственный ридер для перфокарт. Это — адаптированный перевод оригинального гайда DIY Paper Tape/Punch Card Maker and Reader с сайта Instructables.

Что понадобится для сборки привода

1. Плоский кабель.
2. Провода.
3. Два 1х10 соединителя с пинами, male-разъём.
4. Пара деревяшек.
5. 10 фоторезисторов.
6. 10 LED-светодиода диаметров по 3 мм.
7. Одна большая перфоплата или две платы 4х20.
8. Паяльник и припой.
9. Стриппер для снятия изоляции с проводов.
10. Резистор на 10 Ом.
11. Плата Parallax Propeller Activity Board.
12. Плоттер или принтер.

Начинаем паять ридер для перфокарт

Припаяйте фоторезисторы к перфоплате в один ряд. С другой стороны соедините выводы фоторезисторов между собой.

Возьмите плоский кабель с 10 линиями, зачистите провода с обоих концов на 3 мм и залудите их. Припаяйте их к 1х10-коннектору.

Первые 9 проводов должны быть припаяны к перфоплате, а не к фоторезисторам. Выводы не должны касаться их.

Последний десятый вывод будет питать фоторезисторы. Припаяйте его к другой стороне перфокарты от первых девяти выводов.

Возьмите другой кусок перфокарты и припяйте к ней светодиоды так же, как вы припаяли фоторезисторы. Обратите внимание: полярность каждого светодиода должна совпадать с полярностью следующего.

Возьмите ленточный кабель и припаяйте один провод к стороне платы с LED, а другой провод — к другой стороне. К концу кабеля прикрепите male-коннектор на 2 пина.

Возьмите 1х10-коннектор и припаяйте 9 резисторов сопротивлением 10 кОм по одному к каждому выводу. Другой вывод каждого резистора должен быть соединён к следующему резистору. Последний резистор припаивается к 10 выводу.

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

Собираем наше устройство воедино:

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

Подготовьте деревянный корпус для считывателя перфокарт: наметьте отверстия для фоторезисторов и LED. Между двумя половинами устройства должен быть паз высотой в 1.5 миллиметра: он понадобится для того, чтобы вставлять в него будущую перфокарту.

Подсоедините платы с фоторезисторами и LED к корпусу и приклейте их.

Программируем чтение перфокарт в Propeller

Propeller Tool — это инструмент, который позволяет программировать микроконтроллеры Propeller 1 и 2. В нём мы напишем код, который поможет нашему устройству читать перфокарты.

Создаём свою перфокарту

В качестве основы для перфокарты нужно взять плотный картон. Отлично подойдёт обложка старой картонной папки.

Для того, чтобы нанести перфорацию на картон, используйте программу Silhouette Studio. В ней можно либо запрограммировать резку по картону, если у вас есть плоттер. Если у вас простой принтер, то можно разметить перфорацию, а затем вырезать её самому.

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

Читаем перфокарту

Подключите плату Parallax Propeller к компьютеру и запустите её. Все светодиоды должны загореться. Если Propeller показывает странные сообщения, убедитесь, что выводы фоторезисторов подключены в правильном направлении.

Проведите первокарту через паз ридера. Наше сообщение гласит:

Заключение

Если вам понравился этот гайд, посмотрите другие статьи этого автора — у него много крутых проектов. ? Или прочтите другие материалы по DIY на Tproger:

1. Как сварить своё крафтовое пиво с Arduino
2. Проект на Raspberry Pi — полноценный ноутбук в компьютерной мышке
3. Как сделать умный дом своими руками на Arduino и Яндекс.Алиса — пошаговая инструкция

Однако было бы слишком скучно дойти до магазина и просто купить холодную бутылочку. В этой статье мы предлагаем усложнить задачу, но сделать её гораздо интереснее. Мы расскажем, как стать настоящим пивоваром с помощью Arduino – платой микроконтроллера, которая поможет вам построить собственную домашнюю пивоварню и автоматизировать процесс.

Рассказываем о двух проектах с открытым исходным кодом на Arduino для пивоварения, и как программисты могут применить свои навыки для создания своего крафтового пива.

Open ArdBir

Open ArdBir – это платформа с открытым исходным кодом для автоматизированного приготовления пива. Весь процесс пивоварения управляется через Arduino.

Arduino Uno на OpenArdBir помогает пивовару, управляя всем процессом, через контроллер PID+PWM. Вбивать все необходимые команды можно через поддерживаемые клавиатуру и 20×4 ЖК-дисплей.

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

1. PWM-выход для SSR-реле, управляющего нагревательным элементом.
2. Цифровой выход для реле, управляющего рециркуляционным насосом.
3. Цифровой выход для привода пьезо-сигнализатора.

Контроллер автоматизирует все фазы: от кипячения и добавления хмеля до охлаждения и образования вихря. Освоить Open ArdBir могут как начинающие, так и опытные домашние пивовары.

Настроить систему можно всего лишь с помощью четырёх кнопок и ЖК-дисплея, которые предоставляют всю необходимую информацию на всех этапах.

Вот, как настроил Open ArdBir пивовар на YouTube:

Возможности ArdBir:

1. Автоматический и ручной режимы.
2. Настройка газового или электрического нагрева.
3. Настройка PID/PWM.
4. Выбор единиц измерения.
5. Полностью настраиваемые параметры кипячения и добавления хмеля.
6. Алгоритм контроля температуры PID.
7. Управление мощностью нагрева.
8. Установка и хранение рецептов.
9. Отложенный старт.
10. Поддержка нескольких языков: итальянского, английского, испанского, португальского, русского и норвежского.

Beerduino

Это проект, который создал программист Михаил Дёмин. Однажды он увидел видео, на котором кто-то делает пиво, и сам загорелся этой идеей. После долгих дней написания кода у него получился Beerduino – контроллер, который позволяет варить пиво в домашних условиях.

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

1. Ардуино Мега + Шилд + Экран 3,2 дюйма ssd1289 или ili9341.
2. Твердотельное реле для управления ТЭНом SSR-40DA (или схема на симисторах).
3. Твердотельное реле для управления насосом SSR-10DA, D3808HK (для насоса на переменном токе) или SSR-10DD (на постоянном токе).
4. Термодатчик ds18b20.
5. Блок питания 7.5-9В 1А.
6. Разъемы для подключения термодатчика и насоса GX12-3 и GX12-2.
7. Пластиковый бокс.
8. Пьезо-динамик.
9. Резистор на 4.7кОм.

Заключение

Пивоварение с использованием Arduino открывает перед домашними пивоварами новые возможности: можно создать системы для автоматизации варки до создания комплексных систем управления всем процессом пивоварения.

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

Надеемся, статья вас заинтересовала, и в скором времени весь мир услышит о легендарном пиве “Типичный Программист”. 🙂 Во всяком случае, пригласите нас на дегустацию!

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

Также автор этого чуда составил комбинации клавиш, которые можно получится «ввести». Правда, там пока нет цифр, но автор говорит, что «можно заменить на них некоторые из букв».

Теперь можно прочувствовать каждую букву всей душой.

Почему мы об этом говорим

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

Часть компаний переходит в облака отечественных провайдеров. Например, свое облачное хранилище предлагаем мы в T1 Cloud. За последние месяцы спрос на хранение и обработку данных вырос более чем на 40%. Наплыв пользователей оказался настолько резким, что некоторые локальные операторы в срочном порядке ищут способы нарастить инфраструктурные ресурсы.

Третье решение — частное облако на базе open source. Одним из известных стеков для этих целей является Nextcloud. Его инструментарий позволяет не только хранить данные, но и вести проекты, организовывать конференции. Не менее функциональным решением является Sovereign. С его помощью можно развернуть частное облако для корпоративных и личных целей.

Что предложит Sovereign

Это — набор сценариев Ansible, покрывающих десятки кейсов: от хранения данных и мессенджеров до обеспечения ИБ и мониторинга.

Хранение данных

Хранилище построено на основе открытого приложения ownCloud для синхронизации и совместной работы с файлами. Его представил инженер Франк Карличек, один из соавторов KDE еще в 2010 году. К слову, платформа Nextcloud является форком ownCloud и во многом повторяет её.

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

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

Безопасность

В стек входит VPN-сервер на базе OpenVPN. Можно настроить двухфакторную аутентификацию по RFC6238 с поддержкой Google Authenticator и аппаратных токенов. Для борьбы со спамом авторы предлагают использовать Rspamd, для предотвращения вторжений — fail2ban, а для обнаружения руткитов — rkhunter. Управление брандмауэром реализовано с помощью Uncomplicated Firewall (ufw), который, по сути, является фронтендом для iptables.

Мониторинг

Компонент Monit следит, чтобы все элементы системы работали корректно и предупреждает о нештатных ситуациях. В свою очередь, модуль collectd собирает системную аналитику.

В Sovereign также встроена платформа полнотекстового поиска Solr, безопасный IMAP-сервер Dovecot и Apache для веб-хостинга личных блогов. Исчерпывающий список сервисов можно найти в описании к репозиторию на GitHub. Там же выложена инструкция по настройке Sovereign. Сделать это можно на удаленном сервере или на локальной машине. Руководство покрывает все шаги — от установки пакетов до настройки DNS и мониторинга.

Что касается системных требований, то они достаточно консервативные. Для работы необходим сервер (например, VPS) с 512 МБ оперативной памяти. Разработчики рекомендуют использовать Debian 8.3 или альтернативный Linux-дистрибутив. Дополнительно необходим аккаунт в Tarsnap или любом другом бэкап-сервисе. Приобретать SSL-сертификаты не нужно — Let’s Encrypt предоставит их автоматически после развертки сервера.

Можно ли улучшить стек

За несколько лет вокруг Sovereign сформировалось обширное сообщество — на GitHub проект собрал больше 10 тыс. звезд. Однако отношение к многофункциональным платформам для настройки частных хранилищ неоднозначное. Есть мнение, что они экономят время и позволяют развернуть комплексную систему за считаные часы и даже минуты. С другой стороны, они пытаются решить слишком много проблем разом. В итоге страдает пользовательский опыт, а управлять зоопарком инструментов сложно.

В связи с этим энтузиасты предлагают разного рода улучшения для устоявшегося стека. Так, один из резидентов Hacker News в тематическом треде отметил, что предпочитает использовать для self-hosting решений Docker вместо Ansible из-за большей гибкости и простоты. Хотя здесь не все однозначно — настройка контейнерной среды тоже может вызывать трудности, все зависит от опыта.

Также Sovereign подразумевает настройку собственного почтового сервера. Но есть мнение, что они быстро «тонут» в спаме. Здесь помогут дополнительные защитные меры — сервис RBL, серые списки, фильтрующие входящий спам на уровне SMTP, и утилита SpamAssassin.

Главное, не перепутать

Sovereign является технологическим стеком для развертки корпоративного или личного частного облака. Но существует более масштабная инициатива с аналогичным названием — Sovereign Cloud Stack (SCS). Она не имеет отношения к персональным файловым хранилищам. Это — европейский проект, в рамках которого развивают открытые стандарты для контейнерной и облачной инфраструктуры.

Идейно Sovereign Cloud Stack связан с другой европейской инициативой — Gaia-X. Её цель — создать открытую инфраструктуру данных на базе децентрализованной облачной системы. Инженеры разрабатывают правила безопасного обмена информацией. Одним из первых на практике их опробует Национальный метрологический институт Германии в рамках программы по цифровизации средств проверки метрологических устройств.

По своей сути, новый проект является идейным потомком WarioWare DIY, Super Mario Maker и Toy-Con Garage — они также позволяли «разрабатывать» самодельные игры на приставках Nintendo.

Новый проект объясняет пользователям азы программирования через визуальный интерфейс. Им необходимо взаимодействовать с отдельными существами — нодонами — которые являются чем-то вроде функций.

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

Релиз Game Builder Garage намечен на 11 июня. Цена игры в России — 2699 рублей.

Источник: Nintendo

Для производства предлагается использовать алюминий. Все порты и отверстия спроектированы так, чтобы замена клавиш и подключение кабелей были лёгкими и безопасными. Для увеличения угла наклона на 15 градусов используется съёмная планка, которую можно прикрепить с помощью магнитов. Предусмотрены дополнительные возможности для замены клавиш, переназначения управляющих кнопок и формирования индивидуальной раскладки.

Клавиатура подключается к компьютеру с помощью кабеля USB-C — USB-C или USB-C — USB-A. У самого устройства есть ещё два порта USB-C и два порта USB-A, соответствующих спецификации USB 3.2 Gen 2 со скоростью до 10 Гбит/с. Каждая клавиша оснащена собственным светодиодом, которым можно управлять отдельно через прошивку.

Так, в случае, если пользователь пишет слишком медленно или нажимает не на ту клавишу, то тренажёр бьёт его током. Для реализации этой части устройства, Эндрю ДеГонг, автор проекта, использовал «шокер» от бьющей током авторучки.

Мозг клавиатуры — Raspberry Pi. Именно этот малыш отвечает за анализ поведения пользователя. Распознаванием ошибок при печати занимается нейросеть, созданная автором проекта при помощи библиотеки TensorFlow от Google. В качестве тренировочных данных использовались примеры его правильной печати.

По итогу у Эндрю ДеГонга получился девайс, который имеет несколько тренировочных режимов. При этом если пользователь начинает смотреть на клавиатуру, то светодиоды сообщают ему о том, что клавиатура видит читинг и не одобряет его. Познакомиться с файлами проекта можно в его GitHub-репозитории, а само видео доступно ниже:

Источник: YouTube/3DprintedLife

Энтузиаст по большей части использовал лишь корпус от iPod. Внутрь него он засунул Wi-Fi и Bluetooth-модули, цветной дисплей, аккумулятор на 1000 мАч. Также Дьюпон использовал Raspberry Pi Zero W за 10 долларов, на который он установил специальную версию Spotify в стиле оригинального интерфейса плеера от Apple.

Проект было решено назвать sPot. А его исходный код разработки вместе с инструкцией автор обещал добавить в репозиторий проекта чуть позднее.

Источник: YouTube / Guy Dupont

Энтузиаст с канала Electo решил продолжить идею интеграции компьютера в периферию. Но на этот раз корпусом будет служить не клавиатура, а компьютерная мышь. Автор решил пойти ещё дальше и добавил к устройству встроенное питание, небольшую выдвижную клавиатуру и даже миниатюрный экран. Получилось вот что:

Автономность делает это устройство полноценным ноутбуком, пускай и не таким функциональным и производительным, как его аналоги. Автор рассказывает, что изначально целью проекта на Raspberry Pi было уместить все компоненты в корпусе классической мышки, но позже пришлось моделировать собственную конструкцию и печатать корпус на 3D-принтере.

В качестве микрокомпьютера здесь выступает Raspberry Pi Zero W. Не самая мощная модель из линейки Raspberry (одноядерный процессор 1 ГГц и 512 МБ LPDDR2), но зато весьма компактная. Экран имеет диагональ всего 1.5 дюйма. Очевидной сложностью в использовании является тот факт, что при перемещении курсора вам нужно следить не только за самим курсором, но и за перемещением всего экрана. Однако к этому легко можно привыкнуть, достаточно правильно настроить чувствительность мыши.

Производительности Pi Zero достаточно для запуска классических для микрокомпьютеров приложений. Но вот с запуском Minecraft Pi Edition устройство иногда не справляется. Но автору всё же удалось начать строить себе дом в этой игре.

Детальнее про этот проект на Raspberry Pi и про его сборку можно узнать в этом видео.

Примечание Адресные светодиоды (ARGB) отличаются от обычных тем, что имеют в себе цифровую микросхему, которая управляет цветами светодиода и соединяется с другими такими же микросхемами. Таким образом, если последовательно соединить адресные светодиоды, то можно будет управлять отдельно каждым светодиодом в этой цепочке, а не всеми сразу (как было бы с обычными RGB-светодиодами).

Светодиодное облако

Конструкция так же проста, как и эффектна. На каркас в форме шара наклеивается кусками вата, внутри каркаса размещаются адресные светодиоды. Их можно заменить на обычную RGB-ленту или даже гирлянду. Но используя ARGB-светодиоды, можно запрограммировать их на эффект молний или просто для одновременного свечения нескольких цветов.

Фоновая подсветка монитора Ambilight

Ещё в 2002 г. компания Philips разработала технологию динамической фоновой подсветки. Заключается она в том, что по вертикальным краям телевизора были размещены лампы, которые подсвечивали стену цветом, соответствующему цветам на экране. В тёмное время такая подсветка размывает резкий переход от яркого экрана к тёмной стене, благодаря чему глазам становится намного проще смотреть. Помимо этого, ambilight визуально расширяет границы экрана.

DIY-щик Alex Gyver подробно рассказывает про эту технологию и объясняет, как самостоятельно собрать собрать такую подсветку:

LED-панели

Среди светодиодных панелей особенно популярными стали модели от компании Nanoleaf. Они представляют из себя сегменты различных форм (треугольники, квадраты, шестиугольники), которые соединяются между собой и наклеиваются на стены и потолки. Мягкое свечение и приятные цветовые режимы добавят красочности в любой интерьер. Но цены на такие наборы из 9 классических треугольных панелей начинаются от 15 000 ₽.

Собрать подобное освещение можно и самому. Так сделал автор канала Nerdforge. Он решил использовать ленту адресных светодиодов и панели в форме шестиугольников:

Корпус панелей распечатан на 3D-принтере, а в роли рассеивателя — матовый акриловый лист. Микроконтроллером тут выступает ESP32 — прокачанная версия Wi-Fi модуля ESP8266. Имеется удалённое управление со смартфона через приложение Blynk.

Механические светящиеся цветки

Jiri Praus создаёт удивительные механизированные цветки, которые раскрываются от прикосновения и светятся заданными им цветами:

Однако процесс сборки не лёгок: фрезеровка основания, спаянные по каркасу конструкции и тонкие цветочные лепестки, распечатанные на 3D принтере. Эти лепестки раскрываются с помощью системы рычагов и сервопривода. В качестве микроконтроллера тут стоит ESP32, а значит, что цветки можно объединить в одну сеть и удалённо управлять с телефона или компьютера.

Настольная светодиодная лампа

Ещё один популярный проект от Alex Gyver — настольная лампа с множеством режимов:

Роль корпуса в устройстве исполняет матовый плафон, который отлично рассеивает свечение. Вместо адресной светодиодной ленты тут используется матрица светодиодов. Контроллер — ESP8266, который позволяет удалённо настраивать и переключать режимы работы лампы через специальное приложение на телефоне. На верхушке лампы имеется сенсорная кнопка, благодаря которой также можно переключать режимы.

Комплектующее

• Модуль Adafruit Feather M0 Adalogger. Он будет служить в роли микроконтроллера. На борту есть слот под MicroSD карту, на которую будут записываться данные для печати.
• ЖК-дисплей 240х240 пикселей. Через него будет засвечиваться фотополимер.
• Драйвер шагового двигателя.
• Шаговый двигатель. Автор использовал двигатель с DVD-привода.
• Плата с УФ-светодиодами.
• Прочие детали: винты, джамперы, алюминиевая пластина, кнопка (будет запускать процесс печати).
• Непосредственно корпус принтера. Он, в свою очередь, так же распечатан на 3D-принтере (уже на FDM). Файлы для печати корпуса можно найти на Thingiverse.

Подготовка УФ-экрана

Классические ЖК-экраны используют подсветку белого цвета. Для принтера это не годится, ведь фотополимер обычно рассчитан на УФ-излучения. Поэтому нужно аккуратно удалить штатную подсветку ЖК-дисплея и присоединить вместо неё плату с УФ-светодиодами. Закрашивая отпределённые пиксели на экране, можно контролировать засвечивание тех или иных точек на слое смолы (через белые пиксели будет проходить УФ-свет, через чёрные — нет).

Сборка 3D-принтера

Распечатайте все детали корпуса. Печатать лучше на максимальном качестве, ведь 3D-принтеры не любит неточности.

Подключать шаговый двигатель к микроконтроллеру нужно через драйвер.

Дно кюветы (резервуар с фотополимерной смолой) нужно закрыть прозрачным пластиком.

Удостоверившись в правильном подключении, соберите все части корпуса воедино. После сборки можно прошивать микроконтроллер и загружать файл печати на карту MicroSD. Для нарезки STL-файлов можно использовать NanoDLP. Полученные изображения нужно конвертировать в 24-битный формат BMP. Каждое изображение нужно поместить в отдельную папку на карте.

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

В этом принтере нет концевика (датчика, который сигнализируют о том, что платформа подошла к краю). Поэтому принтер просто опускает ось до упора, а потом немного приподнимает её. Дальше начнётся сам процесс печати.

Вот такую чудесную малютку напечатала ёлочная игрушка:

Это open source проект, поэтому каждый из вас может модернизировать устройство или создать на его основе нечто другое. Например, этому 3D-принтеру явно не хватает элементов управления, через которые можно было бы выбирать необходимую модель для печати.

Deauther — это прошивка для Wi-Fi модуля ESP8266. Благодаря ей вы получаете устройство, которое может сканировать сети и точки доступа, производить атаки на сети и отключать от них клиентов. Чтобы предотвратить деаутентификацию, нужно как минимум использовать стандарт 802.11w. Он распространён среди устройств, но не так популярен среди точек доступа.

Это устройство может собрать каждый, достаточно лишь приобрести сам модуль. Это могут быть платы серии ESP, NodeMCU, Wemos, Adafruit HUZZAH и другие. Также автор продаёт кастомные платы различных форм-факторов, которые легко можно найти в интернет-магазинах. Например, крайняя плата справа может быть замаскирована под рабочий повер-банк.

Управлять устройством можно 3 способами:

• через встроенные элементы ввода. В этом случае на плате должны размещаться несколько кнопок (или хотя бы энкодер) и миниатюрный экран;
• удалённо через браузер. Вы подключаетесь к созданной устройством точке доступа, и в браузере открываете панель управления. Кроме базовых возможностей, тут есть гибкая настройка устройства и сетевых параметров;
• через последовательный порт. Модуль подключается по USB к любому устройству с serial-монитором (телефон, планшет, ПК).

Алгоритм использования устройства такой:

1. Сканируете сеть или клиентов. В первом случае будут найдены точки доступа, во втором — устройства с Wi-Fi;
2. Выбираете необходимые найденные сети/устройства;
3. В меню выбираете желаемый тип атаки;
4. Устройство самостоятельно производит атаку.

Вот пример работы Deauther. Устройство собрано в виде наручных часов:

Deauther может производить 3 типа атаки:

1. Deauth: атака деаутентификацией. Устройство посылает поддельные пакеты на точку доступа для отсоединения клиента от сети. Так как канал не зашифрован, точка доступа думает, что клиент действительно хочет отключиться от сети и закрывает соединение;
2. Beacon: при этом режиме атаки создаётся большое количество поддельных точек доступа-пустышек, которые могут дублировать целевую сеть;
3. Probe: запутывает Wi-Fi трекеры.

По форм-фактору плата похожа на Arduino Uno. Тут стоит всё тот же ATmega328, есть аналоговые/цифровые порты, некоторые с поддержкой ШИМ. Остался порт ICSP, кнопка RESET и USB-UART мост CH341.

Но эта плата обзавелась и некоторыми доработками:

• microUSB порт вместо громоздкого USB type B;
• дополнительная тактовая кнопка, которая соединяет Pin 2 и GND;
• к каждому цифровому порту подсоединён синий светодиод;
• в углу платы расположился пьезо-излучатель, через который можно воспроизводить звук. Подсоединён на Pin 8;
• рядом с пьезо-излучателем есть переключатель, который может отключать его от микроконтроллера;
• два распаянных адресных RGB светодиода, подсоединённых на Pin 12 и 13;
• необычный дизайн, который точно привлечёт ваше внимание.

В остальном же RGBDuino копирует Arduino Uno и может без проблем использоваться в тех же проектах, где и обычная Uno.

Помимо такого дизайна есть ещё один:

Какой вам больше понравился? Поделитесь этим в комментариях.

Цвет фона обозначает температуру, а толщина круга — загруженность.

Куб состоит из 3 пластин, представляющих из себя матрицу адресных светодиодов разрешением 64×64 каждая. Управляются эти панели микрокомпьютером Raspberry Pi 2 через специальный шилд Adafruit RGB Matrix Bonnet (он обеспечивает питание и управление светодиодной панелью).  Куб связывается с ПК через Wi-Fi. Для этого к Raspberry Pi подключается USB Wi-Fi приёмник, а на компьютере в фоновом режиме запускается скрипт на Python.

Анимация создана на OpenGL шейдере, который обрабатывается прямо на Raspberry Pi. Корпус и подставка, как полагается, были напечатаны на 3D-принтере.

Устройство называется PasswordPump. Оно может хранить в себе до 254 учётных записей (название учётной записи + логин + пароль). Данные хранятся на двух съёмных микросхемах памяти в зашифрованном виде, благодаря шифрованию военного уровня AES128.

При желании можно сделать бэкап в текстовый файл или на резервные микросхемы памяти (не зря они съёмные).

Аппаратный менеджер паролей — как он работает?

Это устройство подключается к ПК через USB кабель. Чтобы получить доступ к устройству (ко всем сохранённым аккаунтам в нём), нужно ввести мастер-пароль. После этого в списке вы должны выбрать нужную учётную запись, а на компьютере поставить курсор в форму ввода. Менеджер паролей сам введёт в ПК данные для авторизации.

Добавлять учётные записи в устройство можно нативно или через монитор последовательного порта на ПК.

Сборка устройства

PasswordPump базируется на плате Arduino Pro Micro. Единственный элемент ввода в устройстве — энкодер. Он позволяет считывать повороты ручки и нажатия на неё (прямо как в колёсике мышки). Информация выводится на небольшой OLED дисплей с разрешением 128×32 пикселей. Ещё понадобится RGB-светодиод (он будет показывать текущее состояние устройства), две микросхемы EEPROM-памяти, печатная плата и некоторый обвес. Вот все необходимые детали:

Вот так выглядит схема устройства и его прототип, собранный на макетной плате:

Автор выбрал модель Arduino Micro, потому что она базируется на чипе ATmega32u4 с аппаратной поддержкой USB-соединения. Это значит, что микроконтроллер можно использовать как HID-устройство. В данном случае — это клавиатура. Устройство имитирует нажатие клавиш, тем самым вводя данные для авторизации.

Исходный код для микроконтроллера можно найти здесь.

После распайки всех элементов на плате, микроконтроллер нужно подключить к ПК и прошить через Arduino IDE. Но автор советует перепрошивать МК отдельно через программатор, так как в таком случае будет перезаписан и загрузчик, из-за чего в памяти освободится немного места, которого очень мало для этого скетча.

Возможности менеджера паролей

Про базовые возможности уже было рассказано выше — в менеджере паролей можно защищённо хранить данные учётных записей и передавать их на ПК. Но это далеко не все возможности PasswordPump:

• автоматическая очистка памяти и возврат к заводским настройкам после 10 неудачных попыток ввода мастер-пароля;
• учётные данные шифруются с помощью AES128, а мастер-пароль хэшируется с помощью SHA256;
• зашифрованные учётные записи и мастер-пароль посолены;
• устройство не уязвимо для стандартных атак на пароли;
• все данные учётных записей могут быть выгружены в текстовый документ для создания резервной копии в виде файла;
• автоматическая блокировка устройства после 1 часа бездействия (нужно будет повторно ввести мастер-пароль);
• генерация пароля из случайных букв, цифр и символов;
• добавление учётных записей через монитор последовательного порта или на самом устройстве с помощью поворотного энкодера;
• редактирование и удаление существующих учётных записей через ПК или само устройство;

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

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

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

Как работает такой умный дом?

Чтобы создать умный дом своими руками, потребуется навык Домовёнок Кузя. Через него можно не только контролировать умный дом, но и интегрировать виртуальные устройства напрямую в Яндекс.Алису. Это значит, что вам не придётся постоянно открывать навык, чтобы просто выключить лампочку. С микроконтроллером навык будет связываться через веб-хуки.

Для веб-хуков отлично подходит платформа Blynk — панель управления устройствами на Arduino и Raspberry Pi. Там вы сможете без труда создать графический интерфейс, через который можно будет управлять устройством по Wi-Fi (а ещё по Ethernet, USB, GSM и Bluetooth).

Какие устройства можно интегрировать в умный дом?

Через навык можно взаимодействовать с обширным количеством устройств: лампочки, розетки, шторы, замки, роботы-пылесосы, термостаты, очистители воздуха, кондиционеры и  чайники. Кроме этого, можно переключать каналы на телевизоре (через универсальный пульт) и менять цвета RGB-ламп.

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

Аппаратная и программная часть

Для того, чтобы собрать умный дом своими руками, мы будет использовать Wi-Fi модуль ESP8266. Процесс разработки на нём почти не отличается от традиционной разработки на Arduino.

Для начала нужно скачать приложение Blynk из GooglePlay или AppStore и зарегистрироваться в нём. После этого нужно создать новый проект и выбрать соответствующий микроконтроллер. Перед вами появится пустая панель, на которой можно размещать элементы управления. Это могут быть кнопки, иконки, слайдеры, индикаторы, выпадающие списки и многое другое.

После создания проекта на вашу почту придёт токен доступа. Его нужно будет указать в скетче и веб-хуках.

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

Примечание Виртуальные порты в Blynk можно представить как переменные, которые синхронизируются между устройством и сервером.

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

Для этого скетча в панели управления Blynk нужно добавить элемент «Button». В его настройках OUTPUT выставить V0, а режим работы переключить в Switch.

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

Голосовое управление светом не мешает управлению им аппаратно. К микроконтроллеру можно подключить физическую кнопку или выключатель, которые тоже будут включать и выключать свет. Если это необходимо, то изменять состояние виртуального порта можно методом Blynk.virtualWrite(port, value). Тогда изменения будут отображаться и на панели управления.

Примечание При работе с механическими кнопками и выключателями не забывайте про дребезг контактов.

Всё работает? Тогда можете переходить к следующему этапу.

Получение веб-хуков

От Blynk вам потребуется не панель управления, а контроль виртуальных портов через GET-запросы. Вот так выглядит веб-хук на изменение состояния порта:

Чтобы включить виртуальный порт, <value> нужно указать как 1, чтобы выключить — как 0.

Помимо этого, значение с порта можно получить таким запросом:

Настройка навыка «Домовёнок Кузя»

Перейдите на сайт навыка и авторизуйтесь там через Яндекс. Далее жмите на Добавить правило HTTP (GET). Перед вами откроется форма настройки правила.

Активационная фраза — название запроса, которое будет отображаться в списке (например «свет на кухне, включение»). Если вы не планируете контролировать умный дом конкретно изнутри навыка, то больше фраза нигде не понадобится. Поле Ответ Кузи тоже оставляйте пустым. В поле URL вставляете соответствующий веб-хук на включение света (виртуального порта). Остальные параметры можно не изменять. После этого нужно сделать идентичное правило на выключение света.

Дальше нужно перейти во вкладку виртуальных устройств и добавить устройство «Лампа». Тут нужно дать название устройству, по которому его будет идентифицировать Алиса. Например: свет, бра, подсветка, лампа или торшер. Место расположения — комната, в которой будет установлено устройство. Это нужно на тот случай, если в нескольких комнатах будут одинаковые по названию элементы. К тому же, одной голосовой командой можно включать и выключать все устройства в определённой комнате.

В Правило на включение/выключение из списка выбираете соответствующие запросы. В лампе имеется возможность управления яркостью. Для этого нужно создать ещё одно правило, но значение параметра value установить как {value}. Тогда в запрос будет подставляться число от 0 до 100, которое будет обозначать требуемую яркость. Вам лишь остаётся обработать это значение в скетче.

Примечание Если вы планируете изменять яркость, то параметр value в веб-хуке на включение нужно изменить с 1 на 100.

Настройка Алисы

В приложении Яндекс перейдите в раздел Устройства→Управление устройствами. Нажмите на кнопку «Добавить»→«Другое устройство». В открывшемся списке найдите навык «Домовёнок Кузя».

Авторизуйтесь в нём. Возможно, нужно будет ввести код объединения устройств, указанный в панели управления умным домом. Потом нажмите на Обновить список устройств.

На этом этом этапе вы уже создали умный дом своими руками. Теперь система полностью готова к голосовому контролю. К ней имеет доступ лишь ваш аккаунт. В настройках виртуальных устройств можно расширить доступ на другие аккаунты.

— Алиса, включи свет.

Однако у программистов того времени кассеты ассоциируются не только с ностальгическими песнями, но и с 8-битными компьютерами. У большинства из них был встроенный (или хотя бы подключаемый) кассетный магнитофон. Через него можно было загружать и сохранять данные, например программы, игры или файлы. Одна кассета вмещала несколько, а то и десяток программ, в зависимости от их размера. К тому же, на одной магнитной ленте размещались 2 или 4 дорожки — это в несколько раз увеличивало объём кассеты.

Список игр на вкладыше кассеты.

К сожалению, до нашего времени дошло скудное количество таких носителей. Часть из них были повреждены, другие потеряны или просто утилизированы. Поэтому энтузиаст JamHamster задумал проект на Arduino: собрать устройство, которое могло бы имитировать кассету, но хранило бы данные не на магнитной ленте, а на карте памяти MicroSD. И, само собой, у него вышло!

Электронная кассета на Arduino

Гаджет полностью помещается в корпус стандартной аудиокассеты. Мозгами проекта, как положено, стала плата Arduino Nano. Из интерфейсов управления: 5 кнопок и маленький OLED-дисплей. В «кассету» подключается карта памяти, на которую записывается нужная информация. Само собой, это не .exe файлы, и даже не .txt, а специальные аудиодорожки, которые содержат в себе код программ. Через меню на встроенном экране выбирается нужный файл, после чего кассета вставляется в магнитофон.

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

Схема внутреннего строения одной из версий кассет

Кассетой это устройство называется не только из-за своего корпуса. С него действительно можно «считать» звук привычным способом. Для этого там есть магнитная пишущая головка, сигнал которой считывается уже другой головкой, но в магнитофоне. Выходной мощности микроконтроллера для этого недостаточно, поэтому сигнал сначала усиливается миниатюрным усилителем PAM8403 (2 x 3Вт).

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

Сам автор отмечает, что создание проекта на Arduino оказалась сложнее, чем ожидалось. Основная трудность заключалась в компоновке всех элементов в столь маленьком корпусе. Например, ему пришлось отпаять некоторые разъёмы модулей и сместить их на проводах. Кое-где автор отпилил уголки плат, потому что те упирались друг в друга. А гнездо для аудиовыхода вообще пришлось делать вручную, чтобы оно влезло по высоте. Одним словом — сплошной геморрой. Но оно того стоило:

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

Через какое-то время у него уже был рабочий прототип. Музыкант написал производителю синтезаторов — они ответили ему, передали нужные схемы и даже спроектировали итоговое устройство. Благодаря этому устройству через протез Бертольт может управлять несколькими параметрами синтезатора, например глубиной эффекта и тональностью звучания.

На видео музыкант подробно рассказывает о принципе работы протеза, о схеме устройства и о том, как это всё это можно связать с синтезатором.

Послушать музыку, которую Бертольт играет только через протез, можно с 07:25.

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

Во второй части автор заканчивает сборку схемы и показывает, как видеокарта отрисовывает картинку.

Немного теории

0:12 Распиновка VGA интерфейса.

0:47 Коротко о том, как монитор отрисовывает изображение.

1:42 На этой диаграмме видно, в какие именно промежутки времени нужно посылать сигналы горизонтальной и вертикальной синхронизации.

Что такое тайминги монитора и от чего они зависят

2:44 Нужно узнать конкретные значения периода синхроимпульсов. По запросу «VGA signal timing» можно легко найти таблицы, в которых приводится зависимость разрешения монитора от таймингов синхроимпульсов. Тайминги — определённые временные участки синхроимпульсов либо задержки между ними. На сайте приведены все популярные разрешения мониторов с соответствующими таймингами. Конечно, даже самые примитивные видеокарты поддерживают несколько разрешений, но наша задача — сделать хоть какую-то.

3:41 У каждого разрешения своя частота отрисовки пикселей. Для конкретной частоты нужен кварцевый резонатор той же частоты. Если кварца выбранной частоты нет, можно замедлить частоту отрисовки пикселей, отсылая несколько пикселей за раз. Тогда с кварцем в 12 МГц можно будет работать с монитором, у которого пиксельная частота, например, 36 МГц. Но в отличие от частоты, тайминги должны оставаться неизменными.

Тайминги зависят как от частоты кварца, так и от разрешения монитора. Возьмём разрешение 800×600. У этого разрешения пиксельная частота равна 40 МГц. Чтобы запустить схему с частотой в 10 МГц, нужно компенсировать частоту количеством отрисовываемых пикселей. Поэтому схема должна работать с разрешением 200×600. Условно за один такт будет отправляться 4 пикселя, поэтому монитор должен определить исходное разрешение как 800×600.

Горизонтальная синхронизация

Счётчик горизонтальной синхронизации

5:49 Начать стоит со схемы, которая будет считать количество пикселей. Схеме нужно понимать, где будет 0-й пиксель, где — 50-й, а где — 200-й (конец отрисовки строки). В данном случае схема должна считать от 0 до 264 (учитывая синхроимпульс). После этого нужен будет второй счётчик, считающий количество строк и, соответственно, выдающий уже вертикальный синхроимпульс, который будет означать начало отрисовки нового кадра.

В схеме будет использоваться двоичный четырёхразрядный счётчик 74LS161. Чтобы досчитать до 264, потребуется 9 бит. Почему именно 9? Чтобы определить максимальное число, до которого досчитает счётчик, нужно возвести двойку в степень его разрядности. 2^8 = 256 — мало, 2^9 = 512 — достаточно, 2^10 = 1024 — излишне много. Так как у одного счётчика на борту всего 4 разряда, то потребуется три микросхемы.

6:28 Сначала у счётчиков нужно объединить контакты питания и «земли». Обнуляться счётчики должны одновременно, поэтому стоит объединить и контакты сброса. Так как три счётчика должны работать как единый, то и тактироваться они должны синхронно. Поэтому контакты тактирования всех трёх счётчиков нужно объединить. У счётчиков есть контакты входа данных, но они не потребуются.

7:05 Чтобы счётчики работали, нужно подать высокий уровень сигнала на разрешающий контакт PE. Так как контакты входа данных не используются, то и контакт Load будет бесполезен. Но стоит обратить внимание на то, что у него отрицательный активный уровень сигнала. Поэтому, чтобы этот контакт не активировался, на него тоже нужно подать высокий уровень сигнала.

7:17 У счётчиков есть второй разрешающий контакт — TE. У первого счётчика его нужно подключить к высокому уровню — счётчик будет увеличиваться при каждом такте. Но остальные два не всегда должны считать — они должны инкрементироваться только при переполнении предыдущего счётчика. Сигнал переполнения счётчика можно снять с контакта Ripple-Carry. Значение второго счётчика будет увеличиваться на единицу при каждом переполнении первого. Поэтому нужно подключить контакт Ripple-Carry первого счётчика к разрешающему контакту TE второго счётчика, а Ripple-Carry второго — к TE третьего.

После всех этих манипуляций получится 12-разрядный счётчик (хоть нужны всего первые 9 разрядов).

7:54 Чтобы посмотреть на работу схемы, можно подключить к выходу каждого счётчика светодиод (желательно через токоограничивающий резистор). Если сейчас подключить питание, то ничего не произойдёт, потому что у схемы нет источника тактирования. Если подключить кварцевый генератор на 10 МГц, то светодиоды будут переключаться так быстро, что будет казаться, что они просто беспрерывно горят. Лучше тактировать схему от генератора.

8:54 Демонстрация работы счётчика на частоте 1 КГц. Но даже на такой частоте переключения светодиодов достаточно быстрые, поэтому можно понизить частоту до 100 Гц.

9:22 Работа счётчика на 10 Гц.

Распознавание тактов

10:00 Следующая задача — заставить схему реагировать тогда, когда значение счётчика (т. е. число на выходе) будет равняться 200, 210, 242, 264. После последнего значения счётчик должен обнуляться. Для начала число 200. В бинарном коде оно выглядит как 011001000. Чтобы определить это число, нужно поставить инверторы на все выходы счётчика, на которых должен быть ноль, а выходы этих инверторов вместе с остальными контактами подключить к 8-входовому элементу И-НЕ. В таком случае на выходе логического элемента ноль будет только тогда, когда с выхода счётчика будет поступать число 200.

Но у этого элемента 8 входов, а выходов со счётчика 9. Решить эту проблему можно не подключая старший бит — он равняется 0 (схема не будет успевать досчитывать до того момента, когда этот бит станет 1).

11:27 Таким же образом нужно будет определить все остальные числа, просто подключая инверторы к нужным битам. Но остаётся число 264. У него в 9 разряде есть единица (в отличие от всех остальных). В этом случае вместо первого бита нужно будет подключить последний.

Схема декодирования тактов

12:25 Чтобы определить все числа, вам не нужно по 8 инверторов на каждое из них — достаточно инвертировать каждый бит по отдельности, и соответственно каждому числу параллельно подсоединить входы И-НЕ элементов (на инвертированные и неинвертированные биты соответственно).

12:50 Инвертировать сигналы будет микросхема 74LS04, которая содержит 6 отдельных инверторов. Этих микросхем понадобится две. Нужно подключить все выходы счётчика к входам инверторов. Не стоит забывать и про питание микросхемы.

13:15 Теперь пришла очередь И-НЕ элементов. Для них будет использоваться микросхема 74LS30, у которой как раз 8 входов. Для начала число 264 — оно будет сбрасывать счётчик. Стоит помнить, что для этого числа первый бит не подключается. Дальше всё просто: где должен быть 0 — подключаете бит к входу логического элемента через инвертор, где 1 — напрямую.

14:50 Чтобы проверить схему, к выходу И-НЕ элемента можно подключить светодиод. У такого элемента отрицательный активный сигнал. Если подключить генератор и отправить 264 такта, то после последнего светодиод потухнет — это и будет сбросом счётчика. Теперь схема сможет автоматически обнулять счётчик при достижении числа 264.

15:43 То же самое теперь нужно сделать с оставшимися 3 И-НЕ элементами и числами 242, 210 и 200. В отличие от числа 264, у этих должен быть подключён первый бит, а отключён — последний.

17:40 Чтобы проверить работу 4 элементов, на вход счётчика нужно последовательно послать сначала 200 тактов, потом ещё 10, 32 и 22. С такой комбинацией светодиоды, подключённые ко выходам элементов, должны последовательно затухать на один такт.

Но после 264-го такта счётчик всё ещё не обнуляется — для этого нужно выход соответствующего логического элемента подсоединить к контакту сброса одного из счётчиков. Схема циклична.

Разрешающие сигналы отрисовки и синхроимпульсов

18:36 Теперь задача стоит в том, чтобы дать схеме понять, когда именно отображать пиксели (между 0-м и 200-м тактом), а когда давать синхроимпульс (между 210-м и 242-м тактом). Для этого будет использоваться RS-триггер с инверсными входами (потому что у выхода логического элемента активный низкий уровень).

19:15 На вход триггера SET нужно подавать сигнал после 264-го такта (за такт до отображения пикселей), а при достижении 200-го такта — сбрасывать триггер (подавать сигнал на вход RESET). В таком случае пиксели нужно отрисовывать только тогда, когда триггер будет установлен. Второй RS-триггер будет подавать синхроимпульс (между 210-м и 242-м тактом). Так как у синхроимпульса активный низкий уровень, то сигнал нужно снимать с инверсного выхода триггера.

19:47 Чтобы сделать два таких RS-триггера, потребуется 4 элемента 2И-НЕ — LS7400. Подключаем питание и перекрёстно соединяем выходы И-НЕ с их входами (согласно схеме). Первый триггер нужно устанавливать при достижении 264-го такта, поэтому подключаем его к выходу соответствующего логического элемента (того самого, который сбрасывает счётчик). Аналогично подключаем сброс триггера к элементу, соответствующему числу 200.

20:33 Если подключить к выходу триггера светодиод, то можно увидеть, как он горит в промежутке от 0-го до 200-го такта и не горит в промежутке от 200-го до 264-го такта.

Таким же способом нужно сделать и второй триггер. Устанавливаться он будет от элемента 210-го такта, а сбрасываться — от 242-го. Если подключить светодиод к выходу второго триггера, то можно увидеть, как он загорается в некотором промежутке, пока не горит первый светодиод.

21:08 Теперь схема знает, в какие именно моменты нужно отображать пиксели, а в какие — давать горизонтальный синхроимпульс. Но задача стоит в том, чтобы попасть в тайминги, приведённые в таблице. Для начала нужно подключить кварцевый генератор к входу тактирования счётчика. Теперь отрисовывать одну строку схема будет всего 26,4 мкс. Чтобы замерить такой незначительный интервал, потребуется осциллограф.

22:20 Замер таймингов счётчика.

Вертикальная синхронизация

Счётчик вертикальной синхронизации

24:11 Если все временные интервалы совпадают, то горизонтальная синхронизация работает как нужно. Теперь соберём схему вертикальной синхронизации. Её работа почти идентична горизонтальной, за исключением того, что схема будет считать не пиксели, а линии. При каждом обнулении счётчика горизонтальной развёртки, счётчик вертикальной будет увеличиваться на единицу. Так же, как и в первом случае, схема должна различать интервалы между 0-й и 600-й строкой, чтобы отображать строки, и интервалы между 601-й и 605-й, чтобы давать вертикальный синхроимпульс. После 628-й строки счётчик должен обнулиться.

Декодирование тактов

25:03 Чтобы определить нужные такты, потребуются всё те же элементы 8И-НЕ. Но есть проблема: у элементов всего 8 входов, а чтобы передать числа нужных тактов, потребуется 10 бит. Но 8-й и 9-й биты можно не подключать. Ведь если 8-й бит будет единицей, то число будет уже 728, а схема не успеет досчитать до него — счётчик сбросится уже на 628-м такте. По этой же причине 9-й бит тоже может быть не подключён.

26:07 Из-за особенностей чисел тут потребуется всего 5 инверторов.

26:33 Создавать второй счётчик будем так же, как первый. Разница лишь в том, что у второго будут использоваться 10 бит вместо 9. Эти 10 бит нужно подать на соответствующие входы инверторов.

26:57 Как и в прошлом случае, те разряды, которые должны быть равны 1, нужно подключить напрямую к входам логического элемента, а те, которые должны быть равны 0 — через инвертор. Выход элемента, соответствующего числу 628, нужно соединить со сбросом счётчика.

Разрешающие сигналы отрисовки и синхроимпульсов

27:30 Для этой схемы тоже понадобится 2 RS-триггера. Первый будет разрешать отображение строк, второй — подавать вертикальный синхроимпульс. Вход SET первого триггера нужно подключить к сигналу сброса счётчика, а вход RESET к выходу 600-го такта. Вход SET второго триггера нужно подключить к выходу элемента 601-го такта, а RESET — к выходу 605-го.

28:06 Тактировать второй счётчик от генератора не нужно. Вход тактирования этого счётчика нужно подсоединить к контакту сброса первого счётчика. Теперь первый считает количество пикселей (горизонтальная синхронизация), а второй — количество строк (вертикальная синхронизация).

Проверка схемы

28:55 Проверка таймингов вертикальной и горизонтальной синхронизации.

Частота вертикальной синхронизации намного меньше, чем у горизонтальной. Это стоит учесть при настройке осциллографа.

30:50 Если все тайминги соответствуют таблице, то эту схему уже можно будет подключить к монитору через VGA интерфейс. Сейчас нужны будут только три контакта: горизонтальная синхронизация (13), вертикальная синхронизация (14) и общий. Все общие контакты разъёма нужно объединить в один. Если схема собрана правильно, то монитор автоматически настроится на разрешение 800×600.

Для желающих собрать: полную схему со списком элементов можно посмотреть на этом сайте.

Примечание Для создания подобной гирлянды вам потребуются минимальные знания в Arduino. Однако если вы в себе не уверены — ничего страшного:

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

• Arduino Uno;
• адресная светодиодная лента на WS2811;
• источник питания для ленты.

Светодиодная лента

Светодиодная лента — это группа из светодиодов, размещённых на гибком и клейком основании. Лента может быть длиной от 30 см до 5 м.

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

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

• раздельные адресные светодиоды;
• светодиоды в виде бочонков;
• полусферические светодиоды (вариант 1, вариант 2);
• светодиоды в виде ёлочных шишек;
• светодиоды в раздельных сферах;
• светодиоды наподобие гирлянды.

Для примера будет использоваться последний тип адресной ленты:

Контроллер

В гирлянде контроллером ленты будет Arduino Uno. Но для этих целей подойдёт всё, что под руку попадётся: различные платы Arduino, МК серии ESP, STM, AVR, PIC, микрокомпьютеры Raspberry Pi. Единственное, о чём ещё следует помнить, это о логическом уровне контроллера. Некоторые из них работают на 3-вольтовой логике, и нужно будет использовать конвертер уровней.

Тока, выдаваемого с Arduino Uno, не хватит на запитывание ленты. Поэтому нужно использовать внешний источник питания на 5В (обратите внимание, некоторые ленты могут запитываться от 12В). Потребляемый ток напрямую зависит от длины ленты, поэтому нужно внимательно подбирать источник питания в зависимости от ваших целей. Минусовые контакты источника питания и контроллера нужно объединить. Плюс от источника питания нужно подключить напрямую к плюсовому контакту ленты. Сигнальный же контакт ленты нужно подключить к любому порту Uno.

Для управления лентой понадобится специальная библиотека. В этой статье детально описывается установка библиотеки Adafruit NeoPixel.

После скачивания zip-файла, нужно установить его в Arduino IDE. Переходите в Скетч→Подключить библиотеку→Добавить .ZIP библиотеку и выберите нужный файл.

Зажигаем!

Вначале стоит проверить схему на работоспособность. Для этих целей подойдёт следующий код:

Если все компоненты исправны и схема собрана корректно, то вы увидите примерно такую картину:

Если же немного изменить код, то можно заставить светодиоды загораться один за другим:

Такая гирлянда подойдёт как для наружного применения, так и для традиционного размещения на ёлке.

В этой статье будет описан принцип создания собственных смарт-часов на базе популярного микроконтроллера ESP8266.

Определение функциональности часов

В этой статье мырассмотрим часы, которые смогут выводить текущее время и дату, отображать погоду в вашем городе и позволят удалённо управлять Wi-Fi реле. Это означает, что прямо с часов вы сможете управлять любым прибором, подключённым к розетке, будь то музыкальный центр или электрочайник.

Чтобы получать текущее время, необязательно использовать модуль реального времени. Если смарт-часы будут иметь доступ к интернету, то понадобится ближайший NTP-сервер. С его помощью можно достаточно точно узнать текущее время. Чтобы контролировать Wi-Fi реле в часах, будет использоваться Blynk.

Blynk — это облачный сервис, позволяющий с помощью приложения для Android или iOS контролировать устройства на Arduino, Raspberry Pi или же, в данном случае, ESP8266.

Подбор элементов

В часах элементами управления будут 3 тактовые кнопки. Экран тут используется доступный — двухцветный OLED 0’96. Для питания нужен аккумулятор, а для зарядки — специальный контроллер. В этих часах используется литий-ионный аккумулятор и соответствующий для него контроллер TP4056.

Не стоит забывать, что ESP8266 работает на 3-вольтовой логике. Для получения необходимого напряжения питания можно использовать любой доступный стабилизатор напряжения на 3,3 В. Остаётся лишь немного деталей: разъём для зарядки, переключатель, несколько светодиодов, набор резисторов и пара конденсаторов.

Создание и распайка печатной платы

Если хотите, чтобы итоговый вариант часов был надёжным и компактным, лучше всего распаять часы на печатной плате. Для создания рисунка печатной платы подойдут, к примеру, Sprint Layout или же EasyEDA.

Вы можете создать печатную плату в домашних условиях либо заказать её у специализирующихся сервисов — те же EasyEDA или JLCPCB. К этим смарт-часам в свободном доступе уже есть Gerber PCB файлы печатной платы.

После получения/создания платы стоит распаять на ней все компоненты. Монтаж SMD компонентов удобнее делать паяльной пастой и паяльным феном. Но такую работу можно будет выполнить и обычным паяльником с тонким жалом.

Подготовка прошивки часов

После того, как все компоненты будут распаяны, можно приступить к программной части. Вначале следует разобраться с API для получения погоды. К примеру, можно использовать Weather API Yahoo.

Примечание С января 2019 года процесс работы с Weather API Yahoo немного изменился. Однако API всё ещё в бесплатном доступе. О том, как получить доступ, детально расписано на их странице.

После получения ссылки с API можно приступить к прошивке микроконтроллера. Сам скетч для Arduino можно взять здесь.

В первую очередь подставьте ваш код аутентификации Blynk в char auth[]. Этот код будет выслан вам на почту сразу после создания нового приложения в Blynk.

Затем введите SSID и пароль от вашей точки доступа Wi-Fi в char* ssid и char* password соответственно.

Скопированную из Weather API ссылку необходимо вставить в const String url.

В BLYNK_CONNECTED() можно вставить код аутентификации Blynk другого ESP модуля, управляющего электрическим прибором (если такой имеется). Этот процесс можно увидеть в видео о создании Wi-Fi реле. И под конец не забудьте в TimeChangeRule указать параметры вашего часового пояса (в методе tellTime()).

Прошивка микроконтроллера

Теперь в Arduino IDE нужно установить все необходимые библиотеки:

1. Time.h и TimeLib.h.
2. Timezone.h.
3. SSD1306.h и SSD1306Wire.h.
4. NTPClient.h.
5. ESP8266WiFi.h и WifiUDP.h.
6. Последняя версия Blynk.

Чтобы прошить ESP8266, нужно подключить его к мосту USB-UART. Все необходимые контакты уже выведены на торец печатной платы. Обратите внимание, что RX контакт одного подключается к TX контакту другого и наоборот. Более подробно о прошивке микроконтроллеров серии ESP8266 можно почитать тут:

Потом в Arduino IDE нужно будет выбрать текущую плату и COM-порт. Зажав кнопку flash на микроконтроллере, начните прошивку. После удачной прошивки остаётся лишь присоединить аккумулятор и ремешок.

Включите часы. Должна высветиться надпись «Connected to Wi-Fi». Если это так, то микроконтроллер прошит, а значит, ваши смарт-часы готовы.

При нажатии на среднюю кнопку на часах будет отображаться текущая дата, время и температура. Две боковые кнопки управляют двумя подключёнными к Wi-Fi реле электрическими приборами.

В 2016 году инженер представил миру вторую версию своего музыкального инструмента. Его комплектация стала более внушительной: 64 флоппи-дисковода, 8 жёстких дисков и 2 сканера. На своём YouTube-канале Павел исполнил более сотни популярных песен.

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

Принцип звучания

В флоппи-приводах, сканерах или же платёжных терминалах источник звука один — шаговый двигатель. В случае с флоппи-приводом он перемещает считывающую головку. При работе двигателя издаётся звук. Изменяя скорость шагового двигателя можно изменять частоту извлекаемого звука, т. е. ноты. Как правило, последовательность этих нот достаётся из midi-файла.

Управление флоппи-приводом

У привода два разъёма — один для питания («mini-molex») и второй для управления (FDD). Запитывается дисковод сразу от 5В и 12В. Отличным решением будет использовать компьютерный блок питания. При работе с ним не забудьте замкнуть контакт PS_ON с контактом COM, чтобы включить его. Однако, подойдёт любой другой БП с такими же напряжениями. Главное, чтобы хватало выходного ампеража.

Разъём «mini-molex» имеет два контакта земли посередине и контакты 12В и 5В по бокам. Контакт 12В расположен слева и нередко с его стороны имеется «ключ», не дающий присоединить штекер не той стороной.

Хоть разъем FDD имеет пугающее количество контактов, оттуда понадобится всего два — 18 и 20.

18 контакт называется «Stepper Direction», и по нему устанавливается направление движения пишущей головки. 20 контакт называется «Step Pulse» и он уже непосредственно «толкает» шаговый двигатель.

Помимо этого нужно разрешить работу двигателя. Для этого нужно замкнуть на землю 12 контакт разъёма «Drive Select B». Это можно сделать либо джампером (перемычкой) между этим контактом и нижним (11 — землёй), либо непосредственно присоединить 12 контакт к проводу земли. Варвары же могут попросту загнуть этот контакт вниз, чтобы тот соприкасался с нижним контактом.

Контроллер

Управлять флопотроном можно со всего, что только можно запрограммировать: Arduino, Raspberry, STM. Подойдут даже обычные микроконтроллеры AVR или PIC. Главное, чтобы контроллер работал на 5-вольтовой логике, иначе нужно будет использовать конвертер логических уровней. В этой статье будет использоваться самая популярная модель платформы Arduino — Uno.

Коммутация

Для простого флопотрона кроме самих флоппи-дисководов и контроллера понадобятся только соединительные провода. Всего к приводу должно идти 5 проводов: 2 управляющих, 12В, 5В и земля.

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

Дополнительными проводами нужно отвести шину питания 5В и землю и подключить их к пинам платы Uno.

Программная часть

Если вы решили использовать Arduino, то в первую очередь нужно установить Arduino IDE. Также стоит помнить, что для работы с клонами Arduino нужно установить соответствующий драйвер CH340G. Обо всём этом можно почитать в нашей статье.

Вначале стоит проверить флоппи-приводы на работоспособность. Для этого можно запрограммировать контроллер на какие-нибудь простые операции. Например такие:

Этот скетч должен заставить флоппи-привод, подключённый к первому каналу (2 и 3 пин), двигать считывающую головку равномерно по всей рабочей длине. Как только головка подходит к концу, направление движения инвертируется и цикл повторяется.

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

Moppy — продвинутый контроллер для флопотрона. Он состоит из двух частей: прошивки для Arduino, которая непосредственно управляет флоппи-приводами, и компьютерной программы, которая посылает команды на контроллер по USB-кабелю.

Скачиваем последний релиз программы. Первый архив содержит скетч для Arduino, второй — программу для ПК.

Примечание Для работы прошивки нужна библиотека «TimerOne». Её можно найти в Менеджере Библиотек. Для этого откройте Скетч→Подключить Библиотеку→Управлять Библиотеками. Через поисковую строку открывшегося Менеджера Библиотек можно найти необходимую библиотеку «TimerOne».

После установки библиотеки прошивка готова к работе. Осталось выбрать порт, к которому подключена Uno, и прошить её.

Первый привод подключается к 2 и 3 пину платы («Stepper Direction» и «Step Pulse» соответственно). Следующий привод к 4 и 5, потом к 6 и 7 и так далее. К Uno можно подключить до 9 приводов (до пина A5). После подключения всех флоппи-приводов можно включать блок питания.

Воспроизведение

В папке с программой для ПК нужно запустить файл bin/MoppyControlGUI.bat. В открывшемся интерфейсе важны только два окна: окно выбора файла и окно выбора порта.

Остаётся лишь выбрать порт, к которому подключена Uno, загрузить midi-файл и нажать на кнопку воспроизведения. Однако, это не весь функционал Moppy. В этой программе, к примеру, можно воспроизводить звук напрямую от midi-устройств.

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

Откуда брать midi-файлы?

Есть несколько источников:

• Найти готовый midi-файл нужной песни. Однако, шанс того, что файл сразу подойдёт для флопотрона, очень мал. Скорее всего, его нужно будет редактировать.
• Специальные программы для midi-файлов. Например MidiEditor. В ней вы сможете как создать новый файл, так и отредактировать существующий (поменять местами или объединить дорожки).
• Нотный редактор. Например Guitar Pro. Для него есть множество готовых композиций, которые с лёгкостью можно экспортировать в midi-файл. Обратите внимание, что каждый канал в midi-файле соответствует отдельному подключённому флоппи-приводу. Обычно к одной нотной дорожке в Guitar Pro подвязываются сразу два канала. Привязку каналов к дорожкам, естественно, можно редактировать.
• Использовать готовые midi-файлы, созданные специально для флопотрона. Например в этом репозитории, или в документах этой группы.

Учёный вложил в проект примерно 20 тысяч долларов. А всё началось с того, что его 11-летний сын «покатался» на Lamborghini Aventador в игре Forza на Xbox и спросил, можно ли построить такой же.

Умное зеркало

Современная тенденция делать всё «умным» не обошла и такой привычный элемент быта, как зеркало. Такой гаджет нередко встречается в фильмах о будущем или каких-нибудь футуристических иллюстрациях. Однако такое зеркало довольно легко изготовить, и по себестоимости оно сравнимо с ценой бюджетного смартфона. В интернете достаточно различных инструкций по изготовлению этого гаджета, но все они сводятся к одной и той же конструкции.

Вам понадобится рамка со стеклом. На лицевую сторону стекла нужно наклеить зеркальную плёнку — от её качества зависит, насколько отражаемое изображение будет чистым. К обратной же стороне стекла крепится источник изображения — от экрана маленького смартфона до 40-дюймового телевизора. Совсем не обязательно, чтобы экран занимал всю площадь зеркала — маленький экран удобно расположить где-нибудь в углу. Важный момент по выбору экрана. Использовать стоит OLED-, а не LED-экраны, ведь у второго есть подсветка, которая будет видна даже в тех местах, где нет изображения.

Следующий пункт — электронная начинка. Самым популярным решением является одноплатный компактный компьютер Raspberry Pi. С ним просто работать и он с лёгкостью помещается в рамку зеркала. Достаточно установить любую ОС и соответствующее ПО. Но такое решение не единственное — можно подключить экран зеркала к вашему ПК или даже использовать начинку какого-нибудь планшета.

Неплохо было бы встроить в боковые стенки колонки, подключить микрофон и установить какого-нибудь ассистента. Вам это ничего не напоминает?

3D-принтер

3D-принтер — очень полезный, выгодный и технологичных инструмент. В руках умельца он превращается в мини-фабрику по производству всего, что душа пожелает. Однако есть в нём кое-что отпугивающее — цена. Не все хотят отдавать за такую вещь десятки тысяч рублей.

Большинство FDM-принтеров (принтеров с технологией послойного наплавления) разных ценовых категорий имеют схожую конструкцию, разница лишь в качестве. Такую конструкцию можно сделать и самому, при этом не опорожнив свой кошелёк.

Вот ещё один принтер, сделанный в основном из содержимого DVD-приводов.

Умные очки

Да-да, и они тоже. Речь пойдёт не об очках виртуальной или дополненной реальности, а именно об умных очках. Тех, что можно увидеть на каждой второй фотографии Сергея Брина. Первая модель Google Glass стоила 1500$. Однако можно сделать умные очки с базовой функциональностью тех же Google Glass, но по гораздо меньшей цене.

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

Варианты электронной начинки разные — многие ставят Arduino Nano, Bluetooth-модуль и 0.96″ дисплей. У такого экрана разрешение скудное — 96×64 точек, что достаточно для каких-то простых целей, но текст на нём уже не прочитать (только если в одну-две строки). Неплохим решением является установка микроконтроллера ESP32 (прокачанная версия популярного WiFi-модуля ESP8266). Там и модули WiFi и Bluetooth уже встроены, вычислительной мощности больше, чем у Nano, да и сам он просто технологичней. Тут по той же причине, что в умном зеркале, стоит ставить именно OLED-дисплей.

Также в очки можно будет поставить элемент управления — сенсорную панель на дужке, которая будет распознавать жесты влево-вправо. Можно даже разместить спереди камеру и делать снимки/видео на подключаемую карту памяти или же сохранять их напрямую на подключенный телефон.

Неплохим решением будет перенести на такие очки пару простых игрушек, например Ping Pong, Tetris, Space Invaders или даже и что-то поновее вроде Flappy Bird. Если встроить в очки акселерометр и подвязать его под управление в играх, то можно будет совмещать процесс игры с полезной разминкой шеи.

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

Роботизированная рука

Несмотря на специфичность такого устройства, оно может найти применение в разных сферах. Роботизированную руку можно запрограммировать на полив цветов или кормление рыб в аквариуме. Можно модернизировать руку под 3D-ручку и у вас получится специфичный 3D-принтер. В зависимости от надёжности конструкции можно даже превратить руку в ЧПУ.

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

Эта рука имеет 5 осей. Управляется она платой Arduino Uno. Контролировать руку можно через мобильное приложение, с которым устройство связывается с помощью Bluetooth-модуля. Все детали руки печатаются на 3D-принтере. Кроме электроники и напечатанных деталей понадобится лишь набор сервоприводов и болты.

В приложении на смартфоне можно не только управлять рукой, но и создавать некие «программы» (последовательность движений руки), которые она может выполнять самостоятельно. Само приложение создаётся в Mit App Invertor — визуальном Scratch-подобном конструкторе Android-приложений.

Если вам интересны подобные механизмы, можно заглянуть на сайт EEZYrobots. Дизайнер и конструктор Carlo Franciscone разработал уже почти десяток роботов разного назначения: дельта-роботы, роботизированные руки, роботы-художники.

Умные часы

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

Некоторые делают простенькие часы на Arduino Nano или ESP8266 и ставят 0.96″ дисплей. Вот один из примеров.

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

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

Комплектация и параметры таких часов уже напоминают промышленные аналоги. Тут устанавливается чип nRF52832, который намного мощней микроконтроллеров Arduino и по некоторым параметрам схож с чипом ESP8266EX. У nRF есть встроенный Bluetooth-модуль и поддержка NFC. Дисплей тут тоже немного лучше — 128×128 точек и 8 цветов.

На плате есть акселерометр и гироскоп. С их помощью можно легко создавать приложения по типу шагомеров. Флэш-память тут внешняя, на 32 МБ. Аккумулятор ёмкостью 110 мАч. Напряжение на аккумуляторе тоже контролируется, для этого тут есть специальный контроллер Linear LTC2941.

В часы прошивается «операционная система» nRF5-SDK, сюда же встраивается JS-движок JerryScript. С его помощью можно писать свои приложения, циферблаты для часов и различные утилиты.

Светодиодные панели

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

Разработчик с ником Nerdforge решил сделать панели самостоятельно — и это того стоило. Делать их он решил в форме шестиугольников. Корпус панели можно распечатать на 3D-принтере или же вырезать из акриловых листов. Переднюю панель так же можно либо вырезать из акрила, либо напечатать. В случае печати можно даже поэкспериментировать в рельефным рисунком.

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

Управлять такими панелями можно двумя способами: использовать специальный контроллер адресной ленты, который управляется ИК-/РЧ-пультом (или же даже просто кнопками на самом контроллере), или управлять с приложения на смартфоне.

Автор выбрал именно второй вариант. Для него, правда, понадобятся ещё некоторые компоненты, в частности контроллер и WiFi-/Bluetooth-модуль. Nerdforge использовал ESP32, хотя можно было воспользоваться даже самой простой ESP-01. Не стоит забывать, что в таком случае контроллер будет выдавать сигналы на 3-вольтовой логике, а адресная лента в свою очередь работает с 5-вольтовой логикой. Автор использовал конвертер уровней.

Приложение, управляющее панелями, создано на платформе blynk.io — среде разработки графических Android-приложений для контроллеров Arduino, ESP, Raspberry Pi и других.

Робот, играющий в шахматы

Шахматы — довольно древняя игра. Её история насчитывает около полутора тысяч лет. Однако шахматные соревнования датируются лишь серединой XIX века. С внедрением компьютеров в массы люди начали пытаться создавать программы, играющие в шахматы. И если ещё в 70-х компьютеры были очень слабы в этой дисциплине, то уже в 1997 году компьютер Deep Blue от IBM выиграл матч из 6 партий у чемпиона мира по шахматам Гарри Каспарова.

Но играть на компьютере — это одно дело, а вести партию настоящими, «живыми» шахматами — дело совсем другое. По этой причине инженеры начали придумывать роботов, которые бы играли с ними в реальной жизни. Вот один из них под названием Chess Bot.

Такой робот представляет из себя коробку, сверху которой игровое поле и манипулятор, передвигающий шахматы. В роли зрения у робота — смартфон со специальным приложением. Это приложение берёт на себя сразу несколько дел. Во-первых, оно работает со специальным шахматным движком. Именно он решает, какой следующий ход делать. Во-вторых, приложение использует компьютерное зрение для распознавания положения фигур на доске. В-третьих, приложение управляет самим манипулятором, который передвигает шахматы, хотя эту часть работы можно было перенести в контроллер. Он тут, к слову, традиционный — Arduino. Сервоприводы тут тоже самые стандартные — SG-90. Такие часто применяются в робототехнике, где не нужна высокая точность и сила.

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

Приложение также может озвучивать некоторые ситуации вроде «Я поставил вам шах!» и «Спасибо за игру!» (или давать ехидные комментарии, тут уж на ваш вкус).

Однако, есть и менее традиционные роботы. Как вам такой?

Комплектация и использование Kano Computer Kit Touch

В комплектацию модели входят:

• основной модуль Raspberry Pi 3;
• сенсорный HD-монитор диагональю 10,1 дюйма;
• блок питания;
• клавиатура с сенсорной панелью;
• SD-карта;
• динамик;
• аккумулятор;
• чехол;
• соединяющие провода для сборки.

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

Ключевой разработкой Kano является сенсорный экран. Проектирование приложений и ПО должно учитывать интерфейс, через который пользователь взаимодействует с системой. Демонстрируя работу современных вычислительных машин, Kano Computer Kit Touch предоставляет пользователю около 150 часов занятий, которые включают изучение языков Python, JavaScript и Unix, а также позволяют экспериментировать с готовыми кодами игр Minecraft, Pong или Snake.

Пока компьютеры учат людей разбираться в коде, человечество тоже старается передать ИИ свои некоторые навыки. К примеру, Мэттью Газдаял (Matthew Guzdial) и Марк Ридл (Mark Riedl) из технологического института Джорджии обучили нейросеть создавать видеоигры на основе метода мимикрии. Данный способ заключается в подражании искусственного интеллекта человеку.

Сервис AIY Projects, запущенный весной 2017 года, ставит своей целью сделать технологии искусственного интеллекта доступными для сторонних разработчиков. Как рассказали представители Google в блоге, особенную популярность наборы для самостоятельной сборки умных устройств снискали у студентов, обучающихся по системе STEM — основное внимание в ней уделяется прикладному применению технических наук.

Подробнее об обновлениях AIY-наборов

Обновление Vision Kit

Новые комплекты Vision Kit — камеры с компьютерным зрением на основе нейронной сети TensorFlow, которая учится распознавать людей и объекты, — получили обновленный одноплатный компьютер Raspberry Pi Zero WH, упрощенную инструкцию по сборке, SD-карту с загруженным ПО, а также новую камеру Raspberry Pi Camera v2.

Что нового в Voice Kit

Обновленная умная колонка Voice Kit, управляемая голосом, теперь тоже базируется на новом Raspberry Pi Zero WH. Также комплект поставки включает в себя USB-кабель и предустановленное ПО для того, чтобы разработчик сразу же мог приступить к сборке и настройке устройства.

Новое приложение-компаньон для Android

Кроме обновлений DIY-наборов компания представила приложение Google AIY Projects, призванное облегчить настройку устройства «по воздуху». Пока доступна только версия для Android, но разработчики обещают вскоре добавить поддержку iOS и Chrome OS.

Компания также обновила сайт и документацию, а также показала площадку AIY-моделей — набор заранее обученных нейросетей, работающих с любыми AIY-наборами.

Voice Kit и Vision Kit появятся в американских магазинах до конца апреля 2018 года, однако компания работает над доставкой комплектов по всему миру.

Тенденции развития технологий говорят о перспективе Интернета вещей (IoT). Поэтому крупные компании стремятся закрепить позиции в этой растущей сфере: так, например, Google представила собственную систему централизованного управления IoT-устройствами — IoT Core.

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

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

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

Чтобы понять, как работает процессор, надо его собрать

Другой подобный, но более масштабный проект — 16-битный компьютер Megaprocessor, созданный Джеймсом Ньюманом, инженером из Великобритании. Компьютер оснащен четырьмя регистрами общего назначения. В процессоре используется 16-разрядный блок АЛУ и 16-разрядный сумматор, объем памяти — 256 байт. Арифметический блок, устройства ввода/вывода и другие подобные схемыразмещаются на отдельных внешних панелях. Megaprocessor имеет в своем распоряжении 10 000 светодиодов, которые наглядно показывают этапы вычислений.

Вся система состоит из 40 000 транзисторов, из которых более 27 000 отводится на память. Вес устройства, работающего на частоте 20 килогерц — около 500 килограммов.

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

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

Проект получился недешевым — Ньюман потратил более 40 000 фунтов стерлингов. Энтузиаст до сих пор продолжает работу над Megaprocessor. Изначально создатель хотел закончить проект за год, но прошло более 5 лет, и Ньюман продолжает улучшать и развивать его.

На комплектующие ушло всего 100 долларов — ребята заказывали наиболее дешевые компоненты.

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

Коротко о Vision Kit

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

Комплект поставки Vision Kit

Как и Voice Kit, выпущенный в мае 2017 года, Vision Kit представляет собой DIY-проект. В комплект входят картонный корпус, печатная плата VisionBonnet, RGB-кнопка запуска, пьезодинамик, комплект объективов, монтажная гайка штатива и другие соединительные компоненты. Для полноценной работы также потребуются Raspberry Pi Zero W, камера Raspberry Pi, SD-карта и блок питания, которые необходимо приобретать отдельно.

Главной компонентой комплекта поставки является плата VisionBonnet для Raspberry Pi. Она оснащена процессором Intel Movidius MA2450 — маломощным процессором для обработки изображений, способным работать с моделями нейронных сетей прямо на устройстве.

Комплект ПО

Предоставляемое программное обеспечение включает в себя три модели нейронных сетей на основе TensorFlow для различных приложений компьютерного зрения. Первая использует MobileNets и способна распознавать тысячу обычных объектов, вторая — лица и их выражения, а третья может классифицировать их.

В комплект ПО включён инструмент для компиляции собственных моделей. Это позволит обучать модели с помощью TensorFlow на своей рабочей машине или в любом облачном сервисе. Google также предоставляет Python API, который даст вам возможность изменять цвета кнопки запуска, настраивать звуки из динамика и получить доступ к четырем выводам GPIO.

Как получить Vision Kit?

Комплект Vision Kit будет доступен для покупки в магазинах с декабря 2017 года. Предзаказ открыт на сайте Micro Center.

Изначальной идеей проектов AIY являлась поддержка людей, занимающихся DIY и желающих ближе познакомиться с наработками в области ИИ. В планах группы запуск серии гайдов по применению машинного обучения. Первым релизом как раз и стал выпуск Voice Kit. Он содержит инструкцию по сбору смарт-колонки в виде картонного короба, в основе которого лежит Raspberry Pi, а также необходимый для программирования SDK.

По заявлению инженера-программиста Google Пита Уордена, инфраструктура, использованная при создании данных, была в свободном доступе. Поэтому и AIY придерживается таких же принципов свободного распространения, что должно позволить охватить большую аудиторию. Уорден отметил:

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

Google верит, что со временем количество акцентов и вариаций языков в активе проекта только увеличится. В отличии от других наборов данных, пользователи могут сами добавлять свой голос в речевые команды. Сайт проекта предлагает внести свой вклад в улучшение работы Voice Kit, просто записав 135 простых слов наподобие «птица», «стоп», «вперёд», последовательности цифр и имена людей.

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

Так, сотрудники Стэнфорда установили, что программа для распознавания языков Equilid, обученная на твитах и сленговых словарях, более точно идентифицирует голосовые команды, чем при обучении на книгах и научных текстах, поскольку так она использует тот же язык, что и люди в обычной жизни. Результаты Equilid оказались даже более точными, чем у Compact Language Detector 2 от Google.

Проект занимает примерно тысячу строк кода и не использует никаких зависимостей. Для удобства и лучшего понимания весь процесс разбит на 184 шага. По прохождении каждого этапа вы сможете скомпилировать проект и увидеть все изменения. Исходный код каждого шага доступен на GitHub.

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

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

Итак, вот список статей:

1. Настройка.
2. Переход в «сырой» режим.
3. «Сырой» ввод и вывод.
4. Отображение текста.
5. Редактор текста.
6. Поиск.
7. Подсветка синтаксиса.
8. Примечания.

Если вам хочется написать ещё какой-нибудь проект самостоятельно, советуем обратить внимание на серию статей, посвящённую созданию ОС на ассемблере и Rust.

1. Начало
2. Разработка блога
3. Добавление переменных шаблона домашней страницы
4. Заключение

Также вы можете посмотреть наш материал по созданию мессенджера с использованием Node.js.

Начало создания блога

Убедитесь, что у вас установлена платформа для разработки Node.js, если нет, то посетите веб-сайт Node.js, чтобы скачать последнюю версию.

Теперь установите пакетный менеджер Yarn, который понадобится для установки зависимостей будущего блога:

Потом создайте папку для блога. Выполните в терминале следующие команды:

На следующем этапе создайте файл package.json, чтобы импортировать все зависимости для блога и добавьте в него следующие строки:

В этом файле объявлены зависимости, которые необходимо установить для разработки и запуска блога:

1. Модуль Cosmic JS Node, чтобы получать данные с Cosmic JS Bucket.
2. Веб-фреймворк Express.
3. ПакетHogan для обработки шаблонов.
4. МодульNodemon для удобства разработки — он автоматически перезагружает приложение, когда в нем произошли изменения.

Выполните следующую команду, чтобы установить зависимости:

Разработка блога

Далее нужно сформировать главную страницу блога. Создайте файл под названием app.js и добавьте в него следующие строки:

Поясним, что происходит здесь:

1. Производится импорт модулей Express, Cosmic JS и т.д.
2. Присоединяются верхний и нижний колонтитулы.
3. При запросе («/») происходит вызов Cosmic JS Bucket для вывода постов и возвращается шаблон index.html.
4. Добавляются данные на страницу в виде глобального хранилища данных — cosmic. Эта структура данных делает вашу реализацию шаблона  интуитивной.

Добавление переменных шаблона домашней страницы

Эта часть процесса является наиболее интересной, потому что она показывает мощь Cosmic JS в сочетании с системой шаблонов Mustache.

Создайте папку под названием views:

Создайте файл index.html в этой папке и добавьте в него следующие строки:

Что здесь происходит:
1. Формируется заголовок (header) с переменными Mustache.
2. Извлекаются данные Cosmic с помощью переменной Mustache {{cosmic}}, которая имеет все необходимое для компоновки динамических данных нашей страницы.
3. Проход по {{}}cosmic.objects.type.posts и вывод постов в блоге.

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

Заключение

Эта сокращенная версия блога доступна для загрузки на странице Cosmic JS Apps. Полная версия блога включает в себя страницу со всеми постами, а также страницу с постами каждого автора. Просмотрите полную версию кода на GitHub и разверните блог с помощью нескольких кликов на панели инструментов Cosmic JS, установив блог в Cosmic JS Bucket.

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

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

Задержка и запаздывание

Итак, давайте разберемся, что же такое задержка? Если вы раньше играли в онлайн-игры, то скорее всего сталкивались с тем, что при нажатии на клавишу или попытке что-то сделать какое-то время в игре ничего не происходит. Такое явление называют «лагом», и оно очень мешает при игре в многопользовательские шутеры.

Задержка происходит из-за физической отдаленности вашего компьютера от сервера, к которому вы подключены. В прошлой статье я рассказывал про определение полномочного сервера. Лаг — это промежуток времени между отправкой данных на сервер и получением подтверждения от сервера.

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

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

Фреймворки

Теперь перейдем к рассмотрению фреймворков, первым из которых будет incheon.gg. Это довольно классный фреймворк, который позволяет делать многое в играх с дискретной и непрерывной физикой, при этом он берет на себя большую часть логики синхронизации клиента и сервера. Очень рекомендую использовать этот фреймворк для начала, если вы не хотите реализовывать сетевое взаимодействие самостоятельно. У него очень грамотная и понятная документация.

Как я написал собственный фреймворк

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

Я давно занимаюсь многопользовательскими играми. Этот фреймворк — квинтэссенция опыта, полученного мной за эти годы. В отличие от incheon.gg, мой фреймворк больше заточен под игры с открытым миром, и в нем нет вышеупомянутой сетевой функциональности. Он больше подходит тем, кто хочет изучить архитектуру игры путем написания каждой части кода самостоятельно.

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

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

Начнем с package.json — основы основ любого проекта на Node.js. Основные зависимости у меня — express, hashmap, morgan, pug и socket.io. Для этого проекта мне будут нужны только socket.io и hashmap. Morgan — это просто полезный инструмент для записи информации, express — широко используемый веб-фреймворк, pug — шаблонизатор. При желании вы можете заменить их на те инструменты, с которыми вам удобнее работать. Пакет hashmap используют для того, чтобы связать id сокета каждого клиента с игровым экземпляром, в то время как socket.io необходим для обеспечения общения в режиме реального времени.

Перейдем к bower.json, который содержит две зависимости на стороне клиента: jquery и howler.js. Ни одна из них нам особо не понадобится, но jquery может упростить вам работу, а howler.js — классная библиотека, которая добавляет в игру звук. Позже я расскажу, как использую howler.js.

В папке lib есть файлы, которые со стороны сервера управляют и сохраняют состояние игры и ее элементов. Entity2D.js и Entity3D.js — классы ES5, которые включают элементы с базовой физикой. Если хотите пойти дальше, можете добавить в класс более детальную физику, гравитацию и т.д.

Обратите внимание, как реализовано независимое обновление частоты смены кадров, о которой говорилось в первой части. Обновления позиции и скорости происходят благодаря deltaTime, что приводит к плавной игре. Player.js — просто расширение Entity2D.js, которое управляет входными данными пользователя помимо базовой физики.

Game.js немного интереснее.

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

Game.prototype.update() обновляет каждый элемент в игре, а Game.prototype.sendState() передает состояние игры каждому клиенту, подключенному к серверу. Единственное, что нужно отметить (и что отличает мою реализацию от других) — я отфильтровываю подключенных в данный момент игроков и отправляю каждому информацию отдельно. Однако вы можете реализовать это по-своему. Я решил сделать именно так, поскольку так мне легче работать на стороне клиента.

Поговорим о папке public. Она содержит статические файлы JavaScript, которые выполняются со стороны клиента.

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

Drawing.js — это объект контекста Canvas, который прорисовывает все последовательности в спрайтах. Файл Game.js использует window.requestAnimationFrame(), чтобы запустить у клиента цикл для отправки входных данных пользователя на игровой сервер, а также для исполнения полученных состояний игры.

Этот фрагмент кода показывает, как работает вышеупомянутая функция. Вот ссылка на документацию requestAnimationFrame, если вы не знаете, для чего она нужна. Util.bind() создает функцию, которая связывает контекст объекта Game с функцией update(), чтобы он мог быть вызван с помощью requestAnimationFrame(). Это странный прием, который касается технических особенностей JavaScript, поэтому я не буду обсуждать его. Вы легко можете добиться того же результата при помощи анонимной функции.

Файл Input.js я очень часто использую в своих играх (с некоторыми изменениями). Он связывает обработчики определенных событий, чтобы отслеживать входные данные от клавиатуры/мыши, и сохраняет их для быстрого доступа. Когда я выделяю эту функцию и сохраняю ее в одном классе, мне не приходится беспокоиться о том, чтобы получать входные данные пользователя в любом другом месте.

Хотя Sound.js не используется в демо-модели игры, я немного расскажу о нем здесь. Этот файл содержит некоторые функции потрясающей библиотеки howler.js, которые я использую для воспроизведения звуков в моих играх. После инициализации он создает Howl-объекты для каждого звука, который будет использоваться в игре. Звуки затем могут воспроизводиться с использованием Sound.prototype.play(). Лично я сделал так, что все звуковые файлы должны храниться в папке sound внутри общедоступного каталога, но это можно легко изменить и переделать так, как вы считаете нужным. Я настоятельно рекомендую просмотреть документацию howler.js.

Двигаемся дальше. Папка shared содержит только один файл — Util.js.

Util.js — еще один из тех файлов, которые я часто использую в своих проектах. Он содержит множество вспомогательных функций, которые используются как на стороне клиента, так и на стороне сервера. Папка shared служит для статики, поэтому я могу подключить скрипт из файла HTML и использовать его с помощью require() на стороне сервера, когда мне это потребуется. Вы можете перемещать этот файл, если хотите, просто такая организация удобна для меня.

Кроме этого, я использую папку shared для хранения игровых констант, к которым необходимо иметь доступ как серверу, так и клиенту. Например, у меня есть класс, который выглядит следующим образом:

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

Я использую шаблонизатор pug, но вы легко можете подключить любой другой. И, наконец, в корневой папке у нас есть файл server.js. Это довольно стандартный сервер Node.js, использующий веб-фреймворк express.

В первой части я рассказывал про обработчик событий сокета, и это переработанный, упорядоченный код, где я использую методы, которые были определены в классе Game ранее. Цикл setInterval() просто запускает обновление игры и передачу состояния снова и снова с частотой примерно 60 кадров в секунду.

Что дальше

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

Спасибо, что прочитали!

В 2014 году я впервые побывал на CodeDay в Нью-Йорке. И хотя CodeDay не совсем хакатон, это было моё первое знакомство с подобными мероприятиями. Там мы с моим другом Кеннетом Ли написали многопользовательскую игру в танчики. Так как несколько моих друзей спрашивали меня о том, как я её написал, я решил описать процесс её создания.

В этом посте я вкратце опишу ход своих рассуждений и покажу, как воссоздать архитектуру, а также дам некоторые советы, если вы захотите сделать игру сами. Этот пост рассчитан на тех, кто владеет основами JavaScript и Node.js. Если вы с ними не знакомы, то есть много замечательных онлайн-ресурсов, где можно их изучить.

Прим. перев. На нашем сайте есть много познавательных материалов как по JavaScript, так и по Node.js — обязательно найдёте что-нибудь подходящее.

Бэкенд игры написан на Node.js с использованием веб-сокетов, которые позволяют серверу и клиенту общаться в режиме реального времени. Со стороны клиента игра отображается в HTML5-элементе Canvas. Для начала нам, конечно же, понадобится Node.js. В этой статье описана работа с версией 6.3.1, но вы можете использовать любую версию выше 0.12.

Прим. перев. Если вы не знакомы с веб-сокетами, рекомендуем прочитать наш вводный материал.

Создание проекта

Для начала установите зависимости. Создайте папку проекта, перейдите в неё и запустите следующий код:

Для быстрой настройки сервера целесообразно использовать фреймворк Express, а для обработки веб-сокетов на сервере — пакет socket.io. В файл server.js поместите следующий код:

Это довольно типичный код для сервера на связке Node.js + Express. Он устанавливает зависимости и основные маршруты сервера. Для этого демонстрационного приложения используется только один файл index.html и папка static. Создайте их в корневой папке проекта. Файл index.html довольно простой:

Ваш пользовательский интерфейс может содержать куда больше элементов, поэтому для более крупных проектов CSS-стили лучше помещать в отдельный файл. Для простоты я оставлю CSS в коде HTML. Обратите внимание, что я включил в код скрипт socket.io.js. Он автоматически заработает в рамках пакета socket.io при запуске сервера.

Теперь нужно настроить веб-сокеты на сервере. В конец файла server.js добавьте:

Пока что в игре нет никаких функций, поэтому в обработчик веб-сокетов ничего добавлять не нужно. Для тестирования допишите следующие строки в конец файла server.js:

Эта функция будет отправлять сообщение с именем message и содержимым hi всем подключенным веб-сокетам. Позже не забудьте удалить эту часть кода, так как она предназначена только для тестирования.

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

Запустите сервер командой node server.js и в любом браузере перейдите по ссылке http://localhost:5000. Если вы откроете окно разработчика (нажать правую кнопку мыши → Проверить (Inspect)), то увидите, как каждую секунду приходит новое сообщение:

Как правило, socket.emit(name, data) отправляет сообщение с заданным именем и данными серверу, если запрос идет от клиента, и наоборот, если запрос идет от сервера. Для получения сообщений по конкретному имени используется следующая команда:

С помощью socket.emit() вы можете отправить любое сообщение. Можно также передавать объекты JSON, что для нас очень удобно. Это позволяет мгновенно передавать информацию в игре от сервера к клиенту и обратно, что является основой многопользовательской игры.

Теперь пусть клиент отправляет некоторые состояния клавиатуры. Поместите следующий код в конец файла static/game.js:

Это стандартный код, который позволяет отслеживать нажатие клавиш W, A, S, D. После этого добавьте сообщение, которое оповестит сервер о том, что в игре появился новый участник, и создайте цикл, который будет сообщать серверу о нажатии клавиш.

Эта часть кода позволит отправлять на сервер информацию о состоянии клавиатуры клиента 60 раз в секунду. Теперь необходимо прописать эту ситуацию со стороны сервера. В конец файла server.js добавьте следующие строки:

Давайте разберёмся с этим кодом. Вы будете хранить информацию о всех подключенных пользователях в виде объектов JSON. Так как у каждого подключённого к серверу сокета есть уникальный id, клавиша будет представлять собой id сокета подключённого игрока. Значение же будет другим объектом JSON, содержащим координаты x и y.

Когда сервер получит сообщение о том, что присоединился новый игрок, он добавит новый вход в объект игроков при помощи id сокета, который будет в этом сообщении. Когда сервер получит сообщение о движении, то обновит информацию об игроке, который связан с этим сокетом, если он существует.

io.sockets.emit() — это запрос, который будет отправлять сообщение и данные ВСЕМ подключённым сокетам. Сервер будет отправлять это состояние всем подключённым клиентам 60 раз в секунду.

На данном этапе клиент ещё ничего не делает с этой информацией, поэтому добавьте со стороны клиента обработчик, который будет отображать данные от сервера в Canvas.

Этот код обращается к id Canvas (#canvas) и рисует там. Каждый раз, когда от сервера будет поступать сообщение о состоянии, данные в Canvas будут обнуляться, и на нём в виде зеленых кружков будут заново отображаться все игроки.

Теперь каждый новый игрок сможет видеть состояние всех подключенных игроков на Canvas. Запустите сервер командой node server.js и откройте в браузере два окна. При переходе по ссылке http://localhost:5000 вы должны будете увидеть нечто похожее:

Вот и всё! Если у вас возникли проблемы, посмотрите архив с исходным кодом.

Некоторые тонкости

Когда будете разрабатывать более функциональную игру, целесообразно разделить код на несколько файлов.

Такие многопользовательские игры — отличный пример архитектуры MVC (модель-представление-контроллер). Вся логическая часть должна обрабатываться на сервере, а всё, что должен делать клиент — это отправлять входные пользовательские данные на сервер и отображать информацию, которую получает от сервера.

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

Теперь данные о движении будут отправляться на сервер в зависимости от характеристик компьютера более 60 раз в секунду. Это приведёт к тому, что игрок будет передвигаться невероятно быстро. Так мы переходим к концепции определения полномочного сервера.

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

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

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

В идеале циклы обновлений как у клиента, так и на сервере не должны зависеть от сокетов. Попытайтесь сделать так, чтобы обновления игры находились за пределами блока socket.on(). В противном случае вы можете получить много странных нелогичных действий из-за того, что обновление игры будет связано с обновлением сокета.

Кроме того, старайтесь избегать такого кода:

В этом отрезке кода обновление координаты х для игрока связано с частотой смены кадров в игре. SetInterval() не всегда гарантирует соблюдение интервала, вместо этого напишите нечто подобное:

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

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

Также попытайтесь создать собственный физический движок. Это сложно, но весело. Если захотите попробовать, то рекомендую прочитать книгу «The Nature of Code», в которой есть много полезных идей.

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

Прим. перев. Также советуем обратить внимание на наше руководство по созданию бота для мессенджера на Python и посмотреть видеокурс, в котором рассказывается о написании автопилота для GTA V — там тоже используется OpenCV.

Что мы будем делать?

Взглянем на изображение, на котором будем искать книги:

Мы видим, что на изображении находятся четыре книги, а также отвлекающие вещи, такие как кружка кофе, чашка Starbucks, несколько магнитов и конфета.

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

Какие библиотеки нам понадобятся?

Чтобы написать систему для поиска и обнаружения книг на изображениях, мы будем использовать OpenCV для работы с компьютерным зрением и обработки изображений. Нам также необходимо установить NumPy для корректной работы OpenCV.

Команды для установки:

Поиск книг на изображениях с помощью Python и OpenCV

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

Откройте свой любимый редактор кода, создайте новый файл с именем find_books.py и начнем:

Начнем с импорта библиотеки OpenCV. Загрузка изображения с диска обрабатывается функцией cv2.imread. Здесь мы просто загружаем его с диска, а затем преобразуем цветовую гамму из RGB в оттенки серого.

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

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

Теперь давайте определим края (т.е. контуры) объектов на изображении:

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

Мы нашли контуры объектов на изображениях. Однако, как вы видите, некоторые из контуров не закрыты — между контурами существуют промежутки. Чтобы убрать промежутки между белыми пикселями изображения, мы применим операцию «закрытия»:

Теперь пробелы в контурах закрыты:

Следующим шагом является фактическое обнаружение контуров объектов на изображении. Для этого мы будем использовать функцию cv2.findContours:

Рассмотрим геометрию книги.

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

Чтобы проверить, является ли контур книгой или нет, нам нужно выполнить цикл по каждому контуру:

Для каждого из контуров мы вычисляем периметр, используя cv2.arcLength, а затем аппроксимируем (сглаживаем) контур, используя cv2.approxPolyDP.

Причина, по которой мы аппроксимируем контур, заключается в том, что он может не быть идеальным прямоугольником. Из-за зашумления и теней на фото вероятность того, что у книги будет ровно 4 вершины, невелика. Аппроксимируя контур, мы решаем эту проблему.

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

Завершим этот пример, показывая полученное изображение и количество найденных книг:

На данном этапе наше изображение будет выглядеть так:

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

Подведем итоги

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

Наш подход состоял в том, чтобы:

1. Загрузить изображение с диска и преобразовать его в оттенки серого.
2. Немного размыть изображение.
3. Применить детектор контуров Canny для обнаружения объектов на изображении.
4. Закрыть любые промежутки в контурах.
5. Найти контуры объектов на изображении.
6. Применить контурную аппроксимацию, чтобы определить, был ли контур прямоугольником и, следовательно, книгой.

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

Вот так будет выглядеть финальная версия нашего приложения:

Технический стек

Нам понадобятся:

• Flask — фреймворк для разработки бэкенда. Поскольку он легкий, это позволит нам сосредоточиться на логике, а не на структуре папок;
• Heroku — хостинг для бесплатного размещения нашего кода;
• Reddit — как источник данных, потому что новые сообщения там появляются каждую минуту.

Создание приложения Reddit

Мы будем использовать Facebook, Heroku и Reddit. Во-первых, убедитесь, что у вас есть учетная запись в каждом из этих сервисов. Затем нужно создать приложение Reddit:

Нажмите кнопку «create an app…» и следуйте инструкциям на экране:

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

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

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

Создание приложения на Heroku

Перейдите на сайт Heroku и создайте новое приложение:

На следующей странице дайте своему приложению уникальное имя. Нажмите «Heroku CLI» и загрузите последнюю версию интерфейса командной строки Heroku для вашей операционной системы. Следуйте инструкциям на экране и вернитесь, как только интерфейс будет загружен.

Создание базового приложения Python

Приведенный ниже код взят с сайта Константиноса Цапраилиса.

Мы будем редактировать файл в соответствии с нашими потребностями. Бот Facebook будет работать следующим образом:

1. Facebook отправляет запрос на наш сервер всякий раз, когда пользователь пишет сообщение на нашей странице Facebook.
2. Мы отвечаем на запрос Facebook и сохраняем идентификатор пользователя и сообщение, которое было отправлено на нашу страницу.
3. Мы отвечаем на сообщение пользователя через Graph API, используя сохранённый идентификатор пользователя и идентификатор сообщения.

Подробный разбор приведенного выше кода доступен на веб-сайте Константиноса Цапраилиса. В этом посте я сосредоточусь главным образом на интеграции Reddit и использовании базы данных Postgres на Heroku.

Прежде чем двигаться дальше, разместим вышеприведённый код Python на Heroku. Для этого вам нужно создать локальный репозиторий Git. Выполните следующие шаги:

Выполните вышеприведенные команды в терминале и поместите вышеуказанный код Python в файл app.py. Потом поместите в Procfile следующее:

Теперь мы должны сообщить Heroku, какие библиотеки Python будет использовать наше приложение. Эти библиотеки должны быть перечислены в файле requirements.txt:

Выполните следующую команду в терминале. Вы получите такой результат:

Теперь мы создадим Git-репозиторий, который затем может быть помещен на серверы Heroku. Для его создания мы должны выполнить следующие шаги:

1. Войти в Heroku.
2. Создать новый репозиторий.
3. Сохранить состояние проекта в репозиторий.
4. Отправить его на Heroku.

Для этого введите следующие команды в терминал:

Сохраните адрес из строки «remote: …» — это адрес вашего Heroku-приложения. Он понадобится нам на следующем этапе.

Создание приложения Facebook

Для создания приложения нам нужна его страница на Facebook. Таково требование Facebook — у каждого приложения должна быть страница.

Теперь нам нужно зарегистрировать новое приложение. Перейдите на страницу создания приложения и следуйте инструкциям ниже:

Затем перейдите в свой файл app.py и замените PAT в строке 9 на Page Access Token, который мы сохранили выше.

Cохраните все и отправьте код в Heroku.

Теперь, если вы перейдете на страницу Facebook и отправите сообщение на эту страницу, вы получите своё собственное сообщение в ответ. Это подтвердит, что мы всё сделали верно. Если сообщение не пришло, проверьте логи Heroku, которые дадут вам некоторое представление об ошибке. Вы можете получить доступ к логам следующим образом:

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

Получение данных с Reddit

Мы будем использовать данные из следующих источников:

• GetMotivated;
• Jokes;
• Memes;
• ShowerThoughts;

Установим praw — Python-библиотеку сайта Reddit. Это легко сделать, введя следующую команду в терминале:

Теперь протестируем некоторые прелести Reddit в оболочке Python. В документации чётко показано, как получить доступ к Reddit и его сообществам. Сейчас самое подходящее время, чтобы использовать client_id и client_secret, которые мы создали в первой части статьи.

Не забудьте добавить в свой собственный client_id и client_secret вместо ****.

В приложении используется limit = None. Это позволит получать как можно больше сообщений. Изображения мы будем использовать только из GetMotivated и Memes, а текстовые сообщения только из Jokes и ShowerThoughts.

Теперь, когда мы знаем, как получить доступ к Reddit, используя библиотеку Python, мы можем продолжить и интегрировать его в app.py.

Добавим несколько дополнительных библиотек в наш файл requirements.txt, чтобы он выглядел примерно так:

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

Но нам нужен идентификатор для каждого изображения или текста, отправляемого пользователю, чтобы не отправлять одну и ту же запись дважды. Чтобы решить эту проблему, мы будем использовать PostgresSQL и идентификаторы постов Reddit (у каждого поста на Reddit есть уникальный id).

Мы будем использовать отношение «многие-ко-многим». Создадим две таблицы:

• пользователи;
• посты.

Сначала определим их в нашем коде, а затем уже разберёмся, как это будет работать:

Таким образом, в таблице будет два поля. Имя будет идентификатором, отправленным с запросом Facebook Messenger Webhook. Посты будут связаны с другой таблицей — «Посты». В таблице сообщений есть имя и URL-адрес. «Имя» будет заполнено идентификатором поста Reddit, а URL — адресом этого поста.

Итак, теперь наш окончательный код будет работать так:

1. Мы запрашиваем список сообщений из определенного сообщества Reddit:reddit.subreddit(subreddit_name).hot(limit=None)
2. Проверяем, был ли конкретный пост отправлен пользователю ранее.
3. Если сообщение уже было отправлено, мы будем продолжать запрашивать посты от Reddit, пока не найдем новую запись.
4. Если сообщение не было отправлено пользователю, мы отправляем сообщение и выходим из цикла.

Итоговый код app.py выглядит так:

Отправьте его в Heroku:

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

Так мы создадим базу данных, которой достаточно для нашего проекта. Теперь нам нужно инициализировать её правильными таблицами. Для этого мы сначала должны запустить оболочку Python на нашем сервере Heroku:

Затем в оболочке Python ввести следующие команды:

Наше приложение готово! Поздравляю!

Некоторые интересные особенности кода

Во-первых, в коде используется функция быстрых ответов интерфейса Facebook Messenger Bot API. Это позволяет нам отправлять некоторые предварительно отформатированные данные, которые пользователь может быстро выбрать. Они будут выглядеть примерно так:

С каждым запросом на публикацию в API Facebook мы отправляем дополнительные данные:

Еще одна интересная особенность кода заключается в том, как мы определяем, является ли сообщение текстом, изображением или видеозаписью. В сообществе GetMotivated некоторые изображения не имеют расширения «.jpg» или «.png» в их URL, поэтому мы полагаемся на:

Вы могли заметить эту строку кода в файле app.py:

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

Следующая функция проверяет, существует ли пользователь с определенным именем или нет. Если он существует, она выбирает этого пользователя из базы данных и возвращает его. Если он не существует, она создает его, а затем возвращает вновь созданного пользователя:

Исходный код приложения также доступен на Github.

Интересное требование возникло на работе, когда мы обсуждали потенциальную необходимость запуска собственного сокращателя URL, потому что механизм универсальных ссылок (в iOS 9 и выше) требует JSON-манифест на https://domain.com/apple-app-site-association.

Поскольку ОС не следует переадресациям, этот манифест должен быть размещен в корневом домене URL-сокращателя.

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

Возник вопрос «Стоит ли создавать свой сокращатель ссылок?», который затем плавно перешел в «Насколько тяжело создать расширяемый сокращатель ссылок в 2017 году?».

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

Lambda во имя победы

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

1. Конечная точка GET/{shortUrl}, которая будет перенаправлять на оригинальный URL.
2. Конечная точка POST/, которая будет принимать оригинальный URL и возвращать сокращенный.
3. index.html — страница, где каждый мог бы легко создать короткий URL.
4. Конечная точка GET/apple-app-site-association, которая обслуживает статичный JSON-ответ.

Все эти вещи могут быть достигнуты с помощью API Gateway и Lambda.
Прим. перев. Чтобы иметь представление о всём спектре сервисов, предоставляемых платформой Amazon Web Services (AWS), советуем прочитать нашу шпаргалку.

У меня получилась следующая структура проекта:

• используется шаблон aws-nodejs фреймворка Serverless;
• каждая конечная точка имеет соответствующую функцию обработки;
• файл index.html в статичной папке;
• тесты написаны таким образом, что могут использоваться как в качестве интеграционных тестов, так и в качестве приемочных;
• скрипт build.sh, облегчающий работу;
• интеграционные тесты ./build.sh int-test {env} {region} {aws_profile};
• приемочные тесты ./build.sh acceptance-test {env} {region} {aws_profile};
• разворачивание ./build.sh deploy {env} {region} {aws_profile}.

Конечная точка GET/apple-app-site-association

Так как JSON статичный, есть смысл вычислить HTTP-ответ заранее и возвращать его каждый раз:

Конечная точка POST/

Для алгоритма сокращения URL можно найти простое и элегантное решение на StackOverflow. Вам нужен только автоматически увеличивающийся ID, вроде того, что вы обычно получаете с помощью RDBMS.

Однако я заметил, что DynamoDB будет более подходящей базой данных по следующим причинам:

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

Но в DynamoDB нет такого понятия, как автоматически увеличивающийся ID, который необходим для алгоритма. Вместо него вы можете использовать атомарный счетчик для симуляции автоматического увеличения за счет дополнительной единицы записи за запрос.

Конечная точка GET/{shortUrl}

Как только мы установили соответствие в таблице DynamoDB, конечная точка перенаправления стала простым взятием оригинального URL и возвращением его как части заголовка Location.

И не забудьте возвращать соответствующий статусу код HTTP, в данном случае 308 (обязательное перенаправление).

Страница GET/index

Наконец, для страницы index мы будем возвращать HTML (и другой тип контента вместе с HTML).

Я решил поместить HTML-файл в статичную папку, которая загружается и кэшируется в первый раз, когда вызывается функция.

Подготовка к работе

К счастью, у меня было много опыта работы с AWS Lambda, поэтому я знаю, что для URL-сокращателя нам необходимо:

• настроить автомасштабируемые параметры для таблицы DynamoDB (для которой у нас есть внутренняя система управления автоматическим масштабированием);
• включить кэширование для API Gateway на производственном уровне.

Будущие улучшения

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

Чтобы это сделать, вы можете:

1. Добавить GSI в таблице DynamoDB к longUrl для поддержки эффективного обратного поиска.
2. В функции shortUrl выполнять GET вместе с GSI для поиска существующих коротких URL.

Более подходящим вариантом будет добавление GSI, нежели создание новой таблицы. Это поможет избежать транзакций между несколькими таблицами.

Статья подойдёт состоявшимся программистам и тем, кто только интересуется, как войти в IT.

Используемые технологии и инструменты

1. Стек MEAN (Mongo, Express, Angular, Node).
2. Сокеты для прямого обмена сообщениями.
3. AJAX для регистрации и входа.

Подготовка

Структура будущего приложения выглядит примерно так:

Установите Node.js и MongoDB. Кроме того, нам понадобится библиотека AngularJS, скачайте её и скопируйте в папку lib каталога Client.

Чтобы сделать пользовательский интерфейс приложения привлекательнее, вы можете воспользоваться любой CSS-библиотекой. Скачайте её и скопируйте в lib.

Примечание: созданный мессенджер можно будет интегрировать в качестве виджета в любой проект.

Серверная часть

Шаг 1. Запуск проекта

Перейдите в каталог Server и выполните команду:

Она запустит новый проект.

Укажите все необходимые сведения. В результате будет создан файл package.json примерно следующего вида:

Шаг 2. Установка зависимостей

• socket.io — JavaScript-библиотека, которая предоставляет двустороннюю связь клиента и сервера в режиме реального времени;
• express — фреймворк Node.js, предоставляющий набор функций для разработки мобильных и веб-приложений. Позволяет отвечать на HTTP-запросы, используя промежуточное ПО, а также отображать HTML-страницы.

Выполнение этих команд установит необходимые зависимости и добавит их в package.json:

Выглядеть они будут примерно так:

Шаг 3. Создание сервера

Создадим сервер, который обслуживает порт 3000 и возвращает HTML-файл при вызове. Для инициализации нового соединения сокету нужно передать HTTP-объект. Событие connection будет прослушивать входящие сокеты, каждый сокет будет выпускать событие disconnect, которое будет вызвано при отключении клиента. Мы будем использовать следующие функции:

• socket.on(...) — ожидает событие, и когда оно происходит, то выполняет функцию обратного вызова.
• io.emit(...) — используется для отправки сообщения всем подключенным сокетам.

Синтаксис следующий:

Создайте сервер с именем server.js. Он должен:

• Выводить сообщение в консоль при подключении пользователя.
• Слушать событие chat message и транслировать полученное сообщение на все подключенные сокеты.
• Когда пользователь отключается, выводить сообщение в консоль.

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

Клиентская часть

Создайте файлы index.html в каталоге Client, style.css в каталоге CSS и app.js в каталоге js.

Client/index.html

Пусть это будет простой HTML-код, который получает и отображает наши сообщения.

Включите скрипты socket.io-client и angular.js в ваш HTML:

socket.io служит для нас клиентом. Он по умолчанию подключается к хосту, обслуживающему страницу.

В результате index.html должен выглядеть примерно так:

CSS/style.css

Чтобы придать нашей странице внешний вид окна чата, добавим немного стилей. Вы можете использовать любую CSS-библиотеку. Получим следующее:

js/app.js:

Создайте Angular-приложение и инициализируйте соединение сокета. Для этого нужны следующие функции:

• socket.on(...) — слушает определенное событие, и, когда оно происходит, выполняет функцию обратного вызова.
• socket.emit(...) — используется для отправки сообщения конкретному событию.

Синтаксис следующий:

Теперь, когда будет набран текст сообщения и нажата кнопка, вызовите функцию отправки сообщения. Когда сокет получит сообщение, отобразите его.

В результате app.js будет выглядеть примерно так:

Запуск приложения

Перейдите в папку с server.js и запустите команду:

Сервер начнет работу на порте 3000. Чтобы в этом убедиться, перейдите по ссылке в браузере:

Ваш собственный мессенджер готов!

Что можно улучшить?

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

Установите Mongoose или MongoDB для работы с базами данных Mongo:

или:

Можете ознакомиться с документацией по их использованию: mongoose и mongodb.

Схема должна получиться примерно следующего вида:

Собеседникам могут быть присвоены следующие статусы:

• Friend — собеседник является другом.
• Pending — собеседник пока не принял запрос.
• Blocked — собеседник заблокирован.

Предположим, что собеседник отклонил запрос на приватную беседу. В таком случае отправитель должен иметь возможность снова направить запрос.

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

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

Некоторые из возможных конечных точек API:

Вот какой мессенджер получился у автора статьи:

Исходный код приложения можно найти на GitHub.

• перемещение;
• оценка шахматной доски;
• минимакс;
• альфа-бета-отсечение.

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

Готовый алгоритм можно найти на GitHub.

Шаг 1. Генерация ходов и визуализация шахматной доски

Мы будем использовать библиотеки chess.js для генерации ходов и chessboard.js для визуализации доски. Библиотека для генерации ходов реализует все правила шахмат. Исходя из этого, мы можем рассчитать все ходы для данного состояния доски.

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

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

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 2. Оценка доски

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

С помощью функции оценки мы можем создать алгоритм, который выбирает ход с наивысшей оценкой:

Единственным ощутимым улучшением является то, что теперь наш алгоритм съест фигуру, если это возможно:

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 3. Дерево поиска и минимакс

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

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

В этом алгоритме рекурсивное дерево всех возможных ходов исследуется до заданной глубины, а позиция оценивается на «листьях» дерева.

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

С минимаксом наш алгоритм начинает понимать основную тактику шахмат:

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Эффективность минимакса в значительной степени зависит от достижимой глубины поиска. Именно это мы улучшим на следующем шаге.

Шаг 4. Альфа-бета-отсечение

Альфа-бета-отсечение — это метод оптимизации алгоритма «минимакс», который позволяет игнорировать некоторые ветви в дереве поиска. Это позволяет нам намного глубже оценить дерево поиска, используя те же ресурсы.

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

Альфа-бета-отсечение не влияет на результат минимакса, оно только ускоряет его.

Этот алгоритм будет более эффективным, если мы сначала проверим те пути, которые ведут к хорошим ходам:

С альфа-бета-отсечением мы получаем значительное улучшение минимакса, как показано в следующем примере:

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 5. Улучшенная функция оценки

Первоначальная функция оценки довольно наивна, поскольку мы просто подсчитываем очки фигур, которые находятся на доске. Чтобы улучшить её, мы начнём учитывать положение фигур. Например, конь в центре доски «дороже», потому что он имеет больше доступных ходов и, следовательно, более активен, чем конь на краю доски.

Мы будем использовать слегка скорректированную версию квадратных таблиц, первоначально описанных в вики Chess Programming.

Применив это улучшение, мы получим алгоритм, который неплохо играет в шахматы, по крайней мере, с точки зрения простого игрока:

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Заключение

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

С помощью методов, которые представлены здесь, мы смогли запрограммировать шахматный алгоритм, который может неплохо играть в шахматы. В финальном алгоритме реализация ИИ занимает всего 200 строк кода — это означает, что базовые принципы довольно просты. Вы можете посмотреть окончательную версию программы на GitHub.

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

• упорядочивание ходов;
• ускорение генерации ходов;
• оценка эндшпиля.

Если вы хотите узнать о шахматных алгоритмах больше, зайдите на Chess Programming Wiki.

Обзор комплекта Voice Kit

Распространяемое аппаратное обеспечение Voice Hardware Accessory on Top (HAT) позволяет осуществлять захват и воспроизведение аудио: плата расширения соединяется с динамиком и звуковой платой с двумя микрофонами, а также содержит контакты GPIO для подключения низковольтных компонентов и гнездовой разъем для блока питания.

Комплект включает в себя инструкции по сборке голосового интерфейса, который может как запускаться непосредственно на устройстве, так и подключаться к облачным сервисам: Google недавно открыла доступ к технологии распознавания речи Cloud Speech API и представила набор инструментов Google Assistant SDK.

Взаимосвязь с Raspberry Pi

Отношение здесь прямое: Voice Kit — совместный проект Google и Raspberry Pi, комплект тестировался на плате Pi 3 версии B и распространяется с 57-м выпуском журнала MagPi. Вот официальный видеообзор:

Идея сделать серию комплектов «собери ИИ сам» появилась после общения с разработчиками, которые выкладывают на Hackster множество проектов, создаваемых на базе технологий Google.

Сообщество энтузиастов очень велико, и уже вчера, сразу после выхода журнала и начала распространения DIY-набора среди подписчиков и по книжным магазинам (в основном, в США и Великобритании), в Сети стали появляться посты с благодарностями. Кто-то собирается добавить голосовое управление к уже имеющимся роботам:

А кто-то просто вывел коробочку на прогулку:

Этот парень собирается отдать комплект бесплатно по репосту (отправка в любую точку мира, можно успеть поучаствовать до 11:00 по московскому времени 06.05):

Что еще интересного?

На Voice Kit, кроме прочего, можно запустить Android Things, что позволяет легко создавать опытные образцы IoT-устройств и затем масштабировать их до готовых коммерческих продуктов. Скачать превью для разработчиков можно на официальном сайте.

В ближайшее время, видимо, предстоит наблюдать гонку «интеллектуального аппаратного обеспечения» — напомним, что недавно Microsoft в попытке обойти конкурентов в сфере цифровых ассистентов обеспечила поддержку голосового интерфейса Cortana для Raspberry Pi 3, выпустив обновление Windows 10 IoT Core.

В минувшие выходные, пролистывая Amazon Web Services, я заметил новый сервис под названием «Rekognition». Я предположил, что это опечатка (recognition — англ. распознавание), но она привлекла мое внимание. Я заинтересовался: что это за сервис? Amazon привык добавлять новые сервисы в свою платформу с пугающей регулярностью, и этот я пропустил.

Я узнал, что в конце 2016 года Amazon выпустила свой собственный сервис для распознавания изображений на базе глубокого обучения на их платформе. Он может распознавать не только лица, но и объекты на фото. Так как сервис довольно новый, подробностей о нём было немного, но мне захотелось немедленно попробовать его. В общем, в течение часа я написал пример веб-страницы, которая может получать фотографии с моей веб-камеры и выполнять элементарное распознавания лица на нем.

Прим. перев. Чтобы не теряться в многочисленных сервисах Amazon, советуем вам прочитать нашу шпаргалку по AWS.

Раньше я занимался технологией распознавания лиц, используя сторонние библиотеки, а также Microsoft Face API, но все попытки создания подобного приложения не увенчались успехом. Но, просматривая документацию «Rekognition», я понял, что AWS API на самом деле очень прост в использовании. Я немедленно принялся за работу.

Цель

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

Сервис Amazon Rekognition позволяет создавать одну или несколько коллекций. Коллекция — это набор лицевых векторов для фотографий, которые вы хотите сохранить.

Примечание: Сервис сохраняет не фотографии, а их JSON-представление.

После создания коллекции вы можете сфотографировать предмет, сравнить его свойства c сохранёнными и вернуть ближайшее соответствие. Звучит просто, не так ли? По правде говоря, разработка фронтенда веб-страницы для получения данных с камеры заняла больше времени, чем написание бэкенда для распознавания.

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

Фронтенд

Я не знал, какую библиотеку использовать для захвата изображения с помощью камеры iMac. В итоге я нашел на GitHub библиотеку JPEG Camera, которая позволяет использовать HTML5 Canvas или Flash для съёмки фото. Я решил использовать её и настроил под себя написанный на JavaScript образец.

Бэкенд

Для бэкенда я использовал Ruby-библиотеку Sinatra, которая может выполнять всю тяжёлую работу с помощью AWS. Я часто использовал Sinatra (на самом деле Padrino) в своих проектах и настоятельно рекомендую эту платформу.

Примечание: Amazon Rekognition предлагает сначала загружать исходные фотографии, которые использует его API, в Amazon S3, а затем обрабатывать их. Я хотел избежать этого ненужного шага и вместо этого отправлять изображения непосредственно в API, что мне в итоге удалось сделать.

Я сумел сделать то же самое с их приветствием Polly . Вместо того, чтобы сохранять аудио в MP3-файл и проигрывать его, у меня получилось закодировать данные MP3 непосредственно в тег <audio> на странице и воспроизвести их оттуда.

Код

Я разместил весь код этого проекта на моей странице на GitHub. Не стесняйтесь использовать и изменять его. Ниже я постараюсь объяснить код более подробно.

Пишем приложение

Прежде всего, вам понадобится учетная запись Amazon AWS. Я не буду вдаваться в подробности, поскольку это несложно, а в случае затруднений можно легко найти информацию в Интернете.

Создание пользователя AWS IAM

Как только вы создали учетную запись AWS, первое, что нам нужно сделать, — создать пользователя Amazon IAM (Identity & Access Management), который имеет права на использование службы Rekognition. Мы также зададим права для Amazon Polly.

В консоли Amazon нажмите на кнопку «Сервисы» в верхнем левом углу, затем выберите «IAM». В меню слева выберите «Пользователи». Вы должны увидеть список существующих пользователей IAM, которых вы создали в консоли, если вы делали это в прошлом.

Нажмите кнопку «Добавить пользователя», расположенную в верхней части списка, чтобы добавить нового пользователя IAM.

Дайте пользователю имя и убедитесь, что вы отметили пункт «Programmatic Access», так как вы будете использовать этот IAM в вызове API.

Далее приведены настройки разрешений. Убедитесь, что вы щелкаете по третьему квадратику на экране с надписью «Attach existing policies directly». Затем в поле поиска «Filter: Policy Type» введите «rekognition». Выберите «AmazonRekognitionFullAccess» из списка, поставив рядом с ним галочку.

Затем измените фильтр поиска на «polly» и поместите галочку рядом с «AmazonPollyFullAccess».

Теперь у этого IAM есть права, достаточные для Amazon Rekognition и Amazon Polly. Нажмите «Next: Review» в правом нижнем углу.

На странице просмотра вы должны увидеть 2 политики использования, дающие вам полный доступ к Rekognition и Polly. Если вы их не видите, вернитесь и повторите предыдущий шаг. Затем нажмите кнопку «Создать пользователя» в правом нижнем углу.

Эта страница важна. Запишите ключи AWS Key и AWS Secret, которые вы указали на этой странице, поскольку нам необходимо включить их в наше приложение ниже.

Это единственный раз, когда вам будут показаны эти ключи, поэтому сохраните их и файл CSV с этой страницы в надёжном месте.

Загрузка кода

Теперь загрузите пример кода с моей страницы GitHub, чтобы вы могли изменить его по мере необходимости. Загрузите код в виде ZIP-файла, либо склонируйте его в вашу рабочую папку.

Первое, что вам нужно сделать, — это создать файл с именем .env в рабочей папке и ввести эти две строки, заменив в них ключи Amazon IAM на свои:

Теперь, если у вас установлен Ruby (не Ruby on Rails), то для установки зависимостей запустите команду:

Для запуска приложения введите эту команду:

Она должна запустить веб-браузер на порте 4567, чтобы вы могли увидеть веб-страницу и начать тестирование:

Использование приложения

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

Сперва создайте коллекцию, щелкнув по ссылке в самом нижнем левом углу страницы. Это создаст пустую коллекцию на серверах Amazon для хранения ваших изображений. Обратите внимание: имя по умолчанию для этой коллекции — faceapp_test, но вы можете изменить его в коде faceapp.rb (строка 17).

Затем, чтобы начать добавление лиц в свою коллекцию, попросите нескольких людей сесть перед вашим компьютером или телефоном и убедиться, что их лицо находится только в рамке для фотографий (несколько лиц сделают сканирование неудачным). Когда всё будет готово, введите их имя в текстовое поле и нажмите кнопку «Добавить в коллекцию». Должно появиться сообщение о том, что данные о лице были добавлены в базу данных.

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

Обратите внимание, что обычный способ работы Amazon Rekognition заключается в том, чтобы загружать фотографию в Amazon S3 Bucket, а затем обрабатывать его оттуда, но я хотел обойти этот шаг и фактически отправить данные фотографии непосредственно в Rekognition как поток байтов, закодированный в Base64. К счастью, aws-sdk для Ruby позволяет использовать оба метода.

Разбор кода

Прежде всего, давайте взглянем на HTML-страницу:

Структура страницы проста: всего несколько блоков, кнопок и ссылок. Обратите внимание, что мы используем jQuery, а также Moment.js для настраиваемого приветствия. Следует обратить внимание на код faceapp.js, который выполняет все сложные задачи и ссылки на библиотеку камер JPEG.

Вы также можете заметить теги <audio> в нижней части файла — это аудио-приветствие, которое мы отправляем пользователю.

Теперь разберем JS-файл приложения:

Это настраивает библиотеку JPEG Camera, чтобы отображать канал на экране и обрабатывать загрузку изображений.

Функция add_to_collection() захватывает изображение с камеры, а затем выполняет запись в конечную точку /upload вместе с именем пользователя в качестве параметра. Функция проверяет, действительно ли вы ввели имя, которое нужно в качестве уникального идентификатора этих данных.

Функция загрузки проверяет вызов и выводит сообщение об успешном завершении или ошибке.

Функция compare_image() вызывается, когда вы нажимаете кнопку «Сравнить изображение». Она захватывает кадр из камеры и передает POST-данные в /compare. Эта конечная точка вернет либо ошибку, либо структуру JSON, содержащую id (имя) найденного лица, а также процент схожести.

Если лицо совпадёт с данными из коллекции, функция отправит имя найденного лица в /speech. Эта конечная точка вызывает службу Amazon Polly, чтобы преобразовать приветствие в файл MP3, который можно воспроизвести пользователю.

Служба Amazon Polly возвращает приветствие в виде бинарного потока MP3, поэтому мы берем этот поток ввода-вывода, шифруем его в формате Base64 и помещаем в качестве закодированной исходной ссылки в теги <audio> на нашей веб-странице. Затем мы можем вызвать .play() для воспроизведения MP3 через динамики пользователя с помощью HTML5 Web Audio API.

Прим. перев. Вы можете узнать о Web Audio побольше, прочитав нашу серию статей по этой теме.

Наконец, в JS-файле приложения есть функция greetingTime(). Она решает, стоит ли говорить «доброе утро / день / вечер» в зависимости от времени суток пользователя.

Теперь взглянем на код Ruby:

Здесь задан блок настройки конфигурации аутентификации AWS и имени коллекции по умолчанию, которое мы будем использовать (вы можете его свободно менять).

Остальная часть кода — это конечные точки, которые Sinatra будет слушать. Он прослушивает GET в /, чтобы отобразить фактическую веб-страницу конечному пользователю, а также слушает вызовы POST к /upload, /compare и /speech, которым JS-файл отправляет данные. Только 3–4 строки кода для каждой из этих конечных точек фактически выполняют задачи распознавания лиц и речи. Подробнее о них можно узнать из документации AWS SDK.

На протяжении последних шести месяцев я работал над созданием языка программирования (ЯП) под названием Pinecone. Я не рискну назвать его законченным, но использовать его уже можно — он содержит для этого достаточно элементов, таких как переменные, функции и пользовательские структуры данных. Если хотите ознакомиться с ним перед прочтением, предлагаю посетить официальную страницу и репозиторий на GitHub.

Введение

Я не эксперт. Когда я начал работу над этим проектом, я понятия не имел, что делаю, и всё еще не имею. Я никогда целенаправленно не изучал принципы создания языка — только прочитал некоторые материалы в Сети и даже в них не нашёл для себя почти ничего полезного.

Тем не менее, я написал абсолютно новый язык. И он работает. Наверное, я что-то делаю правильно.

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

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

Первые шаги

«А с чего вообще начинать?» — вопрос, который другие разработчики часто задают, узнав, что я пишу свой язык. В этой части постараюсь подробно на него ответить.

Компилируемый или интерпретируемый?

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

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

Я хотел создать простой и при этом производительный язык, каких немного, поэтому с самого начала решил сделать Pinecone компилируемым. Тем не менее, интерпретатор у Pinecone тоже есть — первое время запуск был возможен только с его помощью, позже объясню, почему.

Прим. перев. Кстати, у нас есть краткий обзор серии статей по созданию собственного интерпретатора — это отличное упражнение для тех, кто изучает Python.

Выбор языка

Своеобразный мета-шаг: язык программирования сам является программой, которую надо написать на каком-то языке. Я выбрал C++ из-за производительности, большого набора функциональных возможностей, и просто потому что он мне нравится.

Но в целом совет можно дать такой:

• интерпретируемый ЯП крайне рекомендуется писать на компилируемом ЯП (C, C++, Swift). Иначе потери производительности будут расти как снежный ком, пока мета-интерпретатор интерпретирует ваш интерпретатор;
• компилируемый ЯП можно писать на интерпретируемом ЯП (Python, JS). Возрастёт время компиляции, но не время выполнения программы.

Проектирование архитектуры

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

Лексический анализатор / лексер

Первый шаг в большинстве ЯП — это лексический анализ. Говоря по-простому, он представляет собой разбиение текста на токены, то есть единицы языка: переменные, названия функций (идентификаторы), операторы, числа. Таким образом, подав лексеру на вход строку с исходным кодом, мы получим на выходе список всех токенов, которые в ней содержатся.

Обращения к исходному коду уже не будет происходить на следующих этапах, поэтому лексер должен выдать всю необходимую для них информацию.

Flex

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

Одним из основных таких инструментов является Flex — генератор лексических анализаторов. Он принимает на вход файл с описанием грамматики языка, а потом создаёт программу на C, которая в свою очередь анализирует строку и выдаёт нужный результат.

Моё решение

Я решил оставить написанный мной анализатор. Особых преимуществ у Flex я в итоге не увидел, а его использование только создало бы дополнительные зависимости, усложняющие процесс сборки. К тому же, мой выбор обеспечивает больше гибкости — например, можно добавить к языку оператор без необходимости редактировать несколько файлов.

Синтаксический анализатор / парсер

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

Bison

На этом шаге я также думал использовать стороннюю библиотеку, рассматривая Bison для генерации синтаксического анализатора. Он во многом похож на Flex — пользовательский файл с синтаксическими правилами структурируется с помощью программы на языке C. Но я снова отказался от средств автоматизации.

Преимущества кастомных программ

С лексером моё решение писать и использовать свой код (длиной около 200 строк) было довольно очевидным: я люблю задачки, а эта к тому же относительно тривиальная. С парсером другая история: сейчас длина кода для него — 750 строк, и это уже третья попытка (первые две были просто ужасны).

Тем не менее, я решил делать парсер сам. Вот основные причины:

• минимизация переключения контекста;
• упрощение сборки;
• желание справиться с задачей самостоятельно.

В целесообразности решения меня убедило высказывание Уолтера Брайта (создателя языка D) в одной из его статей:

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

Абстрактный семантический граф

В этой части я реализовал структуру, по своей сути наиболее близкую к «промежуточному представлению» (intermediate representation) в LLVM. Существует небольшая, но важная разница между абстрактным синтаксическим деревом (АСД) и абстрактным семантическим графом (АСГ).

АСГ vs АСД

Грубо говоря, семантический граф — это синтаксическое дерево с контекстом. То есть, он содержит информацию наподобие какой тип возвращает функция или в каких местах используется одна и та же переменная. Из-за того, что графу нужно распознать и запомнить весь этот контекст, коду, который его генерирует, необходима поддержка в виде множества различных поясняющих таблиц.

Запуск

После того, как граф составлен, запуск программы становится довольно простой задачей. Каждый узел содержит реализацию функции, которая получает некоторые данные на вход, делает то, что запрограммировано (включая возможный вызов вспомогательных функций), и возвращает результат. Это — интерпретатор в действии.

Варианты компиляции

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

Написать свой компилятор

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

LLVM

LLVM — это коллекция инструментов для компиляции, которой пользуются, например, разработчики Swift, Rust и Clang. Я решил остановиться на этом варианте, но опять не рассчитал сложности задачи, которую перед собой поставил. Для меня проблемой оказалось не освоение ассемблера, а работа с огромной многосоставной библиотекой.

Транспайлинг

Мне всё же нужно было какое-то решение, поэтому я написал то, что точно будет работать: транспайлер (transpiler) из Pinecone в C++ — он производит компиляцию по типу «исходный код в исходный код», а также добавил возможность автоматической компиляции вывода с GCC. Такой способ не является ни масштабируемым, ни кроссплатформенным, но на данный момент хотя бы работает почти для всех программ на Pinecone, это уже хорошо.

Дальнейшие планы

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

Заключение

Надеюсь, эта статья окажется кому-нибудь полезной. Я крайне рекомендую хотя бы попробовать написать свой язык, несмотря на то, что придётся разбираться во множестве деталей реализации — это обучающий, развивающий и просто интересный эксперимент.

Вот общие советы от меня (разумеется, довольно субъективные):

• если у вас нет предпочтений и вы сомневаетесь, компилируемый или интерпретируемый писать язык, выбирайте второе. Интерпретируемые языки обычно проще проектировать, собирать и учить;
• с лексерами и парсерами делайте, что хотите. Использование средств автоматизации зависит от вашего желания, опыта и конкретной ситуации;
• если вы не готовы / не хотите тратить время и силы (много времени и сил) на придумывание собственной стратегии разработки ЯП, следуйте цепочке действий, описанной в этой статье. Я вложил в неё много усилий и она работает;
• опять же, если не хватает времени / мотивации / опыта / желания или ещё чего-нибудь для написания классического ЯП, попробуйте написать эзотерический, типа Brainfuck. (Советуем помнить, что если язык написан развлечения ради, это не значит, что писать его — тоже сплошное развлечение. — прим. перев.)

Я делал довольно много ошибок по ходу разработки, но большую часть кода, на которую они могли повлиять, я уже переписал. Язык сейчас неплохо функционирует и будет развиваться (на момент написания статьи его можно было собрать на Linux и с переменным успехом на macOS, но не на Windows).

О том, что ввязался в историю с созданием Pinecone, ни в коем случае не жалею — это отличный эксперимент, и он только начался.