# AlphaBot2

# Изучаем робота AlphaBot2-Pi

## Сервис раздел

# TODO ТУТ все про 3й питон, нужно это указать, или что-то придумать, а то парашно получается

- [Страница](https://www.waveshare.com/wiki/AlphaBot2-Pi) с роботом
- [Схема](https://www.waveshare.com/w/upload/9/91/AlphaBot2-Base-Schematic.pdf) части с мотороми и аккумами и контроллером заряда (НИЗ)
- [Схема](https://www.waveshare.com/w/upload/7/72/AlphaBot2-Pi-Schematic.pdf) части с креплением для малины (ВЕРХ)
- User [Manual](https://www.waveshare.com/w/upload/1/1f/Alphabot2-user-manual-en.pdf)
- Набор [даташитов](https://www.waveshare.com/wiki/AlphaBot2_Datasheet) с компонентами на плате
- Примеры ```wget https://www.waveshare.com/w/upload/e/ee/AlphaBot2-Demo.7z```

Примеры:

```bash
cd
wget https://www.waveshare.com/w/upload/7/74/AlphaBot2.tar.gz
tar zxvf AlphaBot2.tar.gz
```

Для того чтобы смонтировать директорию с rpi себе на комп нужно следующее:

```bash
mkdir -p tmp/server
sshfs pi@raspberrypi:/home/pi/AlphaBot2 tmp/server
code tmp/server
```

## Знакомство с роботом AlphaBot2-Pi 

![alphabot2-pi](pic/common/alphabot2-pi-3.jpg)

Робот AlphaBot2-Pi состоит из нескольких основных частей:

* База-шасси
* Плата-адаптер
* Одноплатный компьютер Raspberry-Pi
* Камера с поворотным кронштейном
* Ультразвуковой дальномер

### База-шасси

![abchassis](pic/common/AlphaBot2-Base-intro.jpg)

1. Интерфейс управления шасси для подключения платы-адаптера.
2. Интерфейс для подключение ультразвукового дальномера.
3. Светодиодные индикаторы объезда препятствий.
4. Шаровая опора.
5. ST188 - инфракрасный фотоэлектрический датчик для объезда препятствий.
6. ITR20001/T - инфракрасный фотоэлектрический датчик для обнаружения линии.
7. Потенциометр для настройки дистанции объезда препятствий.
8. TB6612FNG - драйвер для моторов на Н-мосте.
9. LM393 - компаратор напряжения.
10. N20 - мотор-редуктор, 1:30, 6V/600RPM.
11. Колеса диаметром 42мм, шириной 19мм.
12. Переключатель питания.
13. Разъем для двух батарей 14500.
14. WS2812B - RGB светодиоды.
15. Индикатор зарядки батареи.
16. Порт зарядки USB 5V.
17. Индикатор питания.

![abadapterboard](pic/common/AlphaBot2-Pi-intro.jpg)

1. Интерфейс управления шасси для подключения к шасси.
2. Интерфейс для подключения Raspberry Pi.
3. Интерфейс подключения сервомоторов.
4. Порт micro USB с USB-UART преобразователем для подключения к Raspberry Pi по UART.
5. LM2596 DC-DC преобразователь.
6. TLC1543 - 10-битный аналогово0цифровой преобразователь для подключения аналоговых датчиков к Raspberry Pi.
7. PCA9685 - 16-канальный 12-битный ШИМ-модуль для работы с сервомоторами.
8. CP2102 - USB-UART преобразователь.
9. Джостик.
10. Инфракрасный приемник.
11. Пьезодинамик (buzzer).

## Сборка робота
Оригинальная инструкция по сборке тут (https://www.waveshare.com/w/upload/1/1a/Alphabot2-pi-assembly-diagram-en.pdf), а так же в папке docs (см. Alphabot2-pi-assembly-diagram-en.pdf).

### Сборка шасси робота

Установите две батареи 14500 **(A)** на базу-шасси AlphaBot2, восьмисантиметровый кабель FC-20P **(B)** вставьте в соответствующий разъем шасси. Вкрутите стойки **(C&D)**.

![chassis](pic/assembly/base_chassis.png)

### Сборка стойки для камеры

![camera1](pic/assembly/camera1.png)

Поместите сервопривод между стойками **(f)** и **(g)** и скрепите винтами (7). Обратите внимание на то,чтобы ротор сервопривода был установлен в правильном направлении.

![camera2](pic/assembly/camera2.png)

Установите насадку **(c)** на сервопривод в специальную выемку в корпусе. Если она не подходит **(g)** под выемку в корпусе - слегка подрежте ее. Закрепите с помощью винтов **(5)**. Далее установите крестообразную насадку **(b)** в основание стойки. Также при необходимости подрежте. Закрутите винты **(5)** с задней стороны основания стойки.

![camera3](pic/assembly/camera3.png)

Вставьте в крестообразную насадку сервопривод и закрепите винтом **(1)**. Второй, еще никуда не установленный, сервопривод прикрепите двумя винтами **(7)** к подставке для камеры **(e)** как показано на рисунке ниже. Установите подставку под камеру **(e)** и сервопривод на собранную ранее стойку **(f&g)** и прикрутите насадку к сервоприводу с помощью винте **(1)**. 

![camera4](pic/assembly/camera4.png)

Вставьте двадцатипяти пиновый FFC кабель в соответствующий разъем на модуле камеры для Raspberry Pi и установите модуль в подставку **(e)**. 

![camera5](pic/assembly/camera5.png)

### Финальная сборка робота

Закрепите стойку для камеры на плате-адаптере с помощью винтов и гаек **(I&J)**, как показано на рисунке ниже. Проведите кабели от сервприводов через отверстие в нижней части платы-адаптера и вставьте коннектор в соответствующие пины на обратной стороне платы-адаптора. Через то же отверстие проведите шлейф от камеры и вставьте его в соответствующий разъем на Raspberry Pi.

![final1](pic/assembly/final1.png)

Соедините Raspberry Pi и плату-адаптер с помощью стоек для печатных плат **(I&J)**.

![final2](pic/assembly/final2.png)

Вставьте кабель FC-20P, установленный на шасси робота, в плату адаптер. Обратите внимание, что коннектор должен вставляться в разъем в соответствие с шелкографией на печатной плате!

![final3](pic/assembly/final3.png)

Установите ультразвуковой дальномер в соответствующий разъем на шасси робота **(G)**. Соедините плату-адаптер с Raspberry Pi с помощью винтов **(I)**. Соедините шасси робота и плату-адаптер с помощью винтов **(F)**.

![final4](pic/assembly/final4.png)


***ОВНИМАНИЕ! РОБОТ МОЖНО СТАВИТЬ НА ЗАРЯДКУ ТОЛЬКО КОГДА ОН ВЫКЛЮЧЕН! ВО ВРЕМЯ ЗАРЯДКИ ТАКЖЕ НЕЛЬЗЯ ПОДКЛЮЧАТЬСЯ К RASPBERRY PI!***

## Установка системы и минимальная настройка.

В этом разделе мы рассмотрим процесс установки операционной системы на Raspberry Pi и рассмотрим способы взаимодействия с ней в операционной системе linux и windows. Предполагается что изучающие это руководство владеют linux консолью, и язаком программирования python. Для того чтобы запустить linux на Raspberry Pi необходимо выполнить следующие действия:

1. Скачать отсюда (https://www.raspberrypi.org/software/operating-systems/#raspberry-pi-os-32-bit) образ ```Raspberry Pi OS ```. Я рекомендую использовать ```Raspberry Pi OS with desktop and recommended software```, этот образ будет содержать большенство вещей необходимых нам в будующем.

2. Распокавать архив, в Windows можно использовать программу Winrar.

3. Записать образ на карту памяти *(обратите внимание, что объем памяти должен быть больше  4Gb)*. Создатели Raspberry Pi советуют использовать для этого программу Etcher (https://www.balena.io/etcher/). Скачиваем ее и устанавливаем себе на компьютер. Нас встретит простой интерфейс. Сначала нужно выбрать образ, потом выбрать карту память на которую мы хотим его записать, и после согласится на запись. Все ваши данные будут удалены с данной карты. Цифрой 1 на изображении указано, где выбирать образ, 2 - где выбирать карту памяти, 3 - начало прошивки.

![raspb1](pic/raspb/rasp5.png)

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

![raspb2](pic/raspb/rasp2.png)

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

![raspb3](pic/raspb/rasp3.png)


![raspb4](pic/raspb/rasp4.png)

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

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

![raspb6](pic/raspb/rasp6.png)

Туда нужно добавить 2 файла:

* ssh.txt - писать в него ничего не нужно, он необходим для того чтобы мы могли подключится к малинке используя сервис ssh ( https://ru.wikipedia.org/wiki/SSH)
* wpa_supplicant.conf - тут необходимо приписать параметры вашей Wi-Fi сети в следующем формате:

```
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="НАЗВАНИЕ ТОЧКИ ДОСТУПА WiFi"
    psk="ПАРОЛЬ WiFi"
    key_mgmt=WPA-PSK
}
```
При создании данного файла система спросит вас:

![raspb7](pic/raspb/rasp7.png)

Соглашайтесь. Нажмите правой кнопкой мышки на файл ```wpa_supplicant.conf```, выберите ```Открыть с помощью```, и откройте с помощью блокнота. Добавьте в открывшийся документ строки, указанные выше, заменив название точки доступа и пароль на свои. Сохраните. Содержимое этого файла будет автоматически перенесено в ```/etc/wpa_supplicant/wpa_supplicant.conf``` при старте системы.

5. Запуск робота. Далее извлекаем карту памяти из компьютера, предварительно воспользовавшись функцией безопасного извлечения, после чего вставляем карту в разъем на Rasbperry Pi, установленную в роботе. ``` ВНИМАНИЕ! Для того, чтобы на этом этапе не возникло проблем, убедитесь в том, что аккумуляторы заряжены. Это очень важно, так как отключение питания во время загрузки системы может привести к неправильной настройке системы. Во время работы с Raspberry Pi робот не должен заряжаться!```
Переводим ```PWR SWITCH``` находящийся снизу робота из состояния ```OFF``` в ```ON``` для включения робота, после чего ждем около 3х минут чтобы система успела применить все настройки. Для того, чтобы на этом этапе не возникло проблем убедитесь что аккумуляторы заряжены, это очень важно потомучто робот в неактивном состоянии когда находится на зарядке.

6. Перейдем к подключению к Raspberry Pi. Для этого воспользуемся бесплатной версией программы MobaXterm, которая позволит нам совершить подключение gj практически любому протоколу. (Скачать можно здесь: https://mobaxterm.mobatek.net/). Установите программу на свой компьютер. Для подключения к Raspberry Pi по ssh сделайте следующее:

Нажамите на кнопку Session в левом верхнем углу программы, выбирите пункт ```New session```:

![rasp8](pic/raspb/rasp8.png)

Далее в появившимся окне установите параметры в соответствии с изображением:

![rasp9](pic/raspb/rasp9.png)

Иными словами вы должны подключится по ssh к хосту с названием raspberrypi и именем пользователя pi. Далее вам предложат ввести пароль:

![rasp10](pic/raspb/rasp10.png)

 Стандартный пароль для Raspberry Pi OS - ```raspberry```, введите его. После чего вы можете сохранить данный пароль в системе, если вам будет так удобнее. После чего система предложет вам ввести команды на исполнение:

![rasp11](pic/raspb/rasp11.png)

Если вы видете такой же вывод, что и на изображении выше - значит все заработало. Если нет, это может свидетельствовать о проблемах с сетью. Первым делом подключитесь к роутеру (обычно он находится на адресе http://192.168.0.1/ или http://192.168.1.1/) и посмотрите список подключенных устройств. 

Если это произошло значит все хорошо и все работает если нет, это свидетельствует о проблемах с сетью. Первое что можно сделать это подключится к роутеру (обычно он находится на адресе http://192.168.0.1/или http://192.168.1.1/) и посмотреть там в списках клиентов расбери. На моем роутере это выглядит так:

![rasp12](pic/raspb/rasp12.png)

Оттуда можно узнать IP адрес. Далее повторите действия пункта 6, только вместо хоста с названием raspberrypi используя полученный IP. Если это тоже не работает остается только одно - отсоеденить Raspberry Pi от робота, подключить к монитору и с помощью клавиатуры и мыши через графический интерфейс поключить Raspberry Pi к сети Wi-Fi.

![rasp13](pic/raspb/rasp13.png)

## Настройка робота.

Для работы с коботом необходимо выполнить ряд настроек. Для начала их нужно будет сделать в специальной консольной программе для конфигурирования Raspberry Pi -  ```raspi-config```, Для чего используем следующую команду:

```bash
sudo raspi-config
```
![robot1](pic/robot/robot1.png)

После чего вы увидене следующее меню:

![robot2](pic/robot/robot2.png)

*Если вам будет удобнее, терминад можно открепить от программы  ModaXterm и перенести в любую область рабочего стола - просто нажмите левой кнопкой мыши на вкладку с терминалом и перетащите в свободную область рабочего стола.*


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

```bash
Interface Options -> Camera -> Yes -> OK
Interface Options -> SPI -> Yes -> OK
Interface Options -> I2C -> Yes -> OK
Interface Options -> Serial Port -> No -> Yes -> OK
```

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

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

```bash
sudo apt update && sudo apt dist-upgrade -y
sudo apt install ttf-wqy-zenhei python-pip python-smbus python-serial
sudo pip install RPi.GPIO spidev rpi_ws281x
```

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

## Упровление компонентами робота.

Для упровления роботом предлагается использовать библиотеку bsp.py. Для того, чтобы воспользоваться ей, ее нужно поместить в папку с вашим проектом и добавить ее в ваш код следующим образом:
```python
import bsp
```
Рассмотрим все компоненты робота и то, как ими можно управлять, какие данные с них можно получить.

### Управление моторами

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

![motor](pic/bsp/motor.png)

Рассмотрим назначение выходов микросхемы:

* PWMA\PWMB - вход для управления скоростью вращения мотора, для канала A  и В (соответственно, для первого и второго мотора) с помощью ШИМ (*англ. PWM*);
* AIN1\AIN2 - входы полумостов канала A; 
* BIN1\BIN2 - входы полумостов канала B;
* А01\А02 - выходы полумостов канала А;
* В01\В02 - выходы полумостов канала В;
* STBY - включение микросхемы;
* VM - вход питания силовой части микросхемы, двигателей;
* VCC - вход питания логической части микросхемы;
* GND - земля.

---

***Н-мост***

Н-мост (англ. H-bridge) - это схема, позволяющая приложить напряжение к нагрузке в разных направлениях. 

![H-bridge](pic/bsp/H-bridge.png)

H-мост состоит из четырех переключателей, котороми могут быть, наппример, транзисторы или реле. Когда ключи S1 и S4 замкнуты, а S2 и S3 разомкнуты, мотор крутится в одну сторону, если же замкнуть S2 и S3, а S4 и S1 разомкнуть - мотор будет крутиться в другую сторону.

---

---
***ШИМ***

ШИМ (широтно-импульсная модуляция, англ. PWM) - способ управления мощностью на нагрузке с помощью изменения скважности импульсов при постоянной амплитуде и частоте импульсов.

![pwm](pic/bsp/pwm.png)

Основные параметры ШИМ-сигнала:

* Ui - мплитуда импульсов;
* Ton - время, когда сигнал включен;
* Toff - время, когда сигнал отключен;
* Tpwm - время периода ШИМ;

Мощность на нагрузке пропорциональна времени включенного и отключенного сигнала.

---


Вернемся к части принципиальной схемы, отвечающей за управление моторам. Видно, что оно осуществляется с помощью четырех пинов GPIO, которые задают напрвление вращения двух моторов (AIN1\AIN2, BIN1\BIN2) и двух пинов с функцией ШИМ (PWMA\PWMB), которые задают скорость вращения.

В библиотеке bsp.py реализован функционал, который позволит вам просто объявить объект-мотор, задать скорость и направление вращения:

```python
m = motor()
speed = 10          # Скорость, по сути напрядение на моторе (0 .. 100)
m.forward(speed)    # Ехать вперед со скоростью speed
m.backward(speed)   # Ехать назад со скоростью speed
m.left(speed)       # Крутиться вправо со скоростью speed
m.right(speed)      # Крутиться влево со скоростью speed
m.stop()            # Остановиться

m.setMotor(10, 20)  # Выставить скорость (ШИМ) 10 на левом колесе, и 20 на правом.
# Скорость может быть от -100 до 100, знак определяет направление
```

### Взаимодействие с пьезодинамиком (buzzer):

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

![buzzer](pic/bsp/buzzer.jpg)

![buzzer_shem](pic/bsp/buzzer.png)

Взаимодествие с пьезодинамиком с помощью библиотеки bsp.py реализовано следующим образом:

```python
b = beep()          
b.on()              # Включить пищалку
b.off()             # Выключить пищалку, пищит до тех пор пока не выключите
```

### Джойстик:

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

![joystick1](pic/bsp/joystick1.png)

![joystick](pic/bsp/joystick.png)

Средствами bsp.py вы можете взаимодействовать с джойстиком следующим образом:

```python
j = joystick()
j.check_ctr()       # Вернет еденицу если нажата крестовина
j.check_a()         # == нажата A
j.check_b()         # == нажата B
j.check_c()         # == нажата C
j.check_d()         # == нажата D
```

Рассмотрим пример взаимодействия с джойстиком с помощью bsp.py:

```python
j = joystick()
b = beep()
while True:         # В бесконечном цикле проверяем нажата ли кнопка
    if j.check_ctr():
        b.on()      # Если нажата, то включаем пьезодинамик и печатаем слово
        print("center")
        while j.check_ctr():
            time.sleep(0.01) # Ждем когда кнопку отпустят
    else:
        b.off()     # Когда кнопку отпустили выключим пьезодинамик
```

### Управление с пульта

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

![ir](pic/bsp/ir.png)

![ir_remote](pic/bsp/ir_remote.jpg)

Средствами bsp.py вы можете взаимодействовать с пультом следующим образом:

```python
IR = IR_controll()
key = IR.getkey()   # Присваеваем переменной key номер нажатой кнопки на пульте
# Метод вернет None если не одна кнопка не нажата, или вернет код кнопки если ее нажали в данный момент, и repeat до тех пор пока кнопку не отпустят
```

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

```python
ir = ir_controll()
while True:
    key = ir.getkey()
    if(key != None and key != "repeat"):
        print(hex(key))
```

### Инфракрасные датчики для обнаружения препятствий

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

![ir_obtacle](pic/bsp/ir_obstacle.png)

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

Средствами bsp.py вы можете взаимодействовать с инфракрасными датчиками следующим образом:

```python
b = ir_bumper()
l = b.check_l()     # Вернет 1 если препятствие зафиксированно левым датчиком
r = b.check_r()     # Вернет 1 если препятствие зафиксированно правым датчиком
```

Пример кода для работы с инфракрасными датчиками. В консоль выводится информация о сенсорах, которые фиксируют обьект:

```python
b = ir_bumper()
while True:
    if b.check_l():
        print ("LEFT")
        time.sleep(0.3)
    if b.check_r():
        print ("RIGHT")
        time.sleep(0.3)
```

### Ультрозвуковой дальномер

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

![ultrasonic1](pic/bsp/ultrasonic.png)

![ultrasonic2](pic/bsp/ultrasonic.jpg)

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

---
***Ультразвуковой дальномер***

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

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

---

Средствами bsp.py вы можете взаимодействовать с ультразвуковыми датчиками следующим образом:

```python
u = us_sensor()
k = u.dist()        # Вернет расстояние до обьекта, считанное сенсором
```

Пример кода который будет выводить расстояние до обьекта до тех пор, пока не будет нажато сочетание клавиш ```Ctrl+C```:

```python
u = us_sensor()
try:
    while True:
        print ("Distance:%0.2f cm" %u.dist())
        time.sleep(0.3)
except KeyboardInterrupt:
    GPIO.cleanup()
```

### RGB диоды.

Для работы с RGB необходимо внести некотрые изменения в конфиг запуска расбери, т.к. такие светодиоды WS2812B требуют очень специфического сигнала управления. Реолизовать его средствами linux не возможно, поэтому на помощь нам приходят такие модули как DMA и PWM. DMA позволяет передовать данные на светодиоды минуя центральный процуссор, а PWM через управление скважностью позволяет передвать данные от DMA в требуемом формате. Но затакую реализацию нужно платить, поэтому одновременно со светодиодами нельзя использовать аудиокарту встроенную в малину. Собственно для ее отключения нам и нужно исправить настройки запуска, для чего:

```bash
sudo nano /boot/config.txt 
```

Нужно добавить в конец файла 2 строки:

```txt
hdmi_force_hotplug=1
hdmi_force_edid_audio=1
```

Также необходимо закоментировать эту строку:

```txt
dtparam=audio=on
```

превратив ее в такую:

```txt
#dtparam=audio=on
```

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

```bash
sudo pip3 install rpi_ws281x adafruit-circuitpython-neopixel
sudo python3 -m pip install --force-reinstall adafruit-blinka
```

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

```python
r = rgb_led()
r.color(0, 255, 255, 255)
r.color(1, 0, 0, 255)
r.color(2, 0, 255, 0)
r.color(3, 255, 0, 0)
```

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

```python
r = rgb_led()
r.color(0, "White")
r.color(1, "Blue")
r.color(2, "Green")
r.color(3, "Red")
```

Доступны следующие цвета:

- Aqua
- Black (выключить диод)
- Blue
- Purple
- Green
- Red
- White
- Yellow

## Датчики линии.

Для отслеживания линии в нижней части робота есть 5 оптических датчиков. Для простого примера можно просто считать с них значения:

```python
l = line_sensor()
while True:
	print(l.AnalogRead())
	time.sleep(0.2)
```

Если поставить робота на трассу (ее можно найти в папке docs), то маленикие значения (< 200) будут полученны с сенсора который находится над черной линией, а большие (> 800) над беым участком трассы.

## Управление положением камеры

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

```python
c = CameraAngle()
c.setCameraAngle(30, 90)
```

Установит на 30 градусов по вертикальной оси и 90 градусов по горизонтальной.

Пример программы которая двигает камерой впрово и влево, а так-же вверх и низ:

```python
c = CameraAngle()

while True:
    for i in range(0, 180, 1):
        c.setCameraAngle(i, i)
        time.sleep(0.02)

    for i in range(180, 0, -1):
        c.setCameraAngle(i, i)
        time.sleep(0.02)
```

# Примеры простых программ:

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

```python
from bsp import rgb_led, line_sensor, motor

m = motor()
r = rgb_led()
l = line_sensor()

colors = {0:4, 1:3, 2:1, 3:0}

delta_sensor = 200

while True:
    c = l.AnalogRead()

    i = 0
    for i in range(4):
        if c[colors[i]] < delta_sensor:
            r.color(i, "Red")
        else:
            r.color(i, "Black")
        i = i+1

    
    if c[1] < delta_sensor:
        m.setMotor(40,0)
    elif c[3] < delta_sensor:
        m.setMotor(30,10)
    elif c[0] < delta_sensor:
        m.setMotor(10,30)
    elif c[4] < delta_sensor:
        m.setMotor(0,40)
    else:
        m.setMotor(10, 10)
```

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

## Компьютерное зрение

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

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

```bash
sudo apt install realvnc-vnc-server realvnc-vnc-viewer
sudo raspi-config
# Interfacing Options -> VNC -> YES
vncserver
```

Потом переходим сюда (https://www.realvnc.com/en/connect/download/viewer/) и качаем оттуда версию для винды.

2. Поставим пакеты для работы с компьютерным зрением:

```bash
sudo apt install libatlas-base-dev
pip3 install numpy opencv-python
```

3. Далее запускаем скрипт предназначенный для подбора параметров.

```python
find_filter.py
```

![cv1](pic/CV/cv_1.png)

Наша задача подобрать минимальное и максимальное значения для 3х парматров h, s, v. Сначало нужно подобрать нижнюю границу параметра h (h1) Для этого нужно двигать первый ползунок до тех пор пока круг не станет быть виден. потом подгоняем максимальное значение h (h2) так чтобы круз все еще отчетливо был виден. Потом также подгоняем второй параметр s и третий v. В итоге должно получится что-то похожее на это:

![cv2](pic/CV/cv_2.png)

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

```txt
(96, 175,70),(85,255,117)
```

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

Далее запустим пример который распознает круг.

```python
circul_detect.py
```

![cv3](pic/CV/cv_3.png)

TODO: Написть че вообще происходит.


## Машинное обучение

Тут в качкстве примера я предложу вам обучить свою нейронную серь на открытом датасете который содержит тысячи изображений цифр - MNIST. Этот датасет уже встроен в библиотеку keras.

Для того чтобы использовать нейронную сеть ее нужно сначала обучить, для этого я предлагаю использовать сервис google colaboratiry - https://colab.research.google.com/notebooks/intro.ipynb, потомучто обучение сетей требует значительных вычислительных мощностей, а гугл готов нам предоставить их бесплатно в образовательных целях. Данный сервис представляет из себя страницу jupiter noutbook код в которой исполняется поблочно. давайте рассмотрим блоки которые нам необходимы для получения обученной сети:

1) Импорт библиотек

```python
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
```

2) Скачивание датасета и преобразованиего в необходимый формат:

```python
# Model / data parameters
num_classes = 10
input_shape = (28, 28, 1)

# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Scale images to the [0, 1] range
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")


# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
```

3) Создание нейронной сети:
TODO: написать что-то про то откуда взялись эти слои

```python
model = keras.Sequential(
    [
        keras.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

model.summary()
```

В резулитате можно увидить структуру созданой сети:

```txt
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 26, 26, 32)        320       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 13, 13, 32)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 11, 11, 64)        18496     
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64)          0         
_________________________________________________________________
flatten (Flatten)            (None, 1600)              0         
_________________________________________________________________
dropout (Dropout)            (None, 1600)              0         
_________________________________________________________________
dense (Dense)                (None, 10)                16010     
=================================================================
Total params: 34,826
Trainable params: 34,826
Non-trainable params: 0
_________________________________________________________________
```

4) Обучение сетки. Это долгий процесс, у меня заняло около 30 мин.

```python
batch_size = 128
epochs = 15

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)
```

5) Проверка точности и сохранение обученой сети.

```python
score = model.evaluate(x_test, y_test, verbose=0)
model.save('mnist_trained_model.h5')
print("Test loss:", score[0])
print("Test accuracy:", score[1])
```

После этого нужно будет перести файл ```mnist_trained_model.h5``` на вышу малину.

Даллее для того чтобы запустить это на пишки нужно доставить еще пакеты:

```bash
pip3 install keras tensorflow
```

После этого запускаем

```bash
number_detect.py
```

TODO: написать про то как это работает.