Тестовые программы для Gertboard


Предыдущая | Следующая

Для платы Gertboard существует множество тестовых программ, написанных на языках программирования C и Python. Язык C обеспечивает наиболее полный дос­туп к функциональным возможностям платы Gertboard, но этот язык труден для восприятия начинающими программистами, поэтому многие программы написаны на Python — такие, например, как пакеты для доступа к портам GPIO на Raspberry Pi, для включения альтернативных функций этих контактов, для доступа к последовательному периферийному интерфейсу (SPI) и широтно-импульсному модуля­тору (ШИМ, PWM) и др. Так что, используя пакеты, написанные на языке Python, можно получить доступ к большинству функциональных возможностей платы Gertboard. Однако микроконтроллер Atmel ATmega запрограммировать без знания языка С вы не сможете.

Далее мы рассмотрим программное обеспечение на языке Python 2.7, созданное, наряду с примерами и документацией по этому языку, Алексом Эймсом (Alex Eames), ведущим блога RasPi.TV на канале YouTube. Это программное обеспече­ние совместимо со всеми текущими ревизиями платы Gertboard и компьютера Raspberry Pi.

Для загрузки программного обеспечения на компьютер Raspberry Pi сначала создадим для него соответствующий каталог, перейдем в него и выполним команду:

sudo mkdir gertboard_python 
sudo chmod 0777 gertboard_python 
cd gertboard_python 
wget http://raspi.tv/download/GB_Python.zi

Затем распакуем в этот каталог полученный архив:

unzip GB_Python.zip 
cd GB_Python 
ls

Команда ls выведет на экран список всех размещенных в каталоге файлов. Большинство из них — файлы программ на языке Python. Для управления GPIO на Python существуют два пакета общего назначения: RPi.GPIO и WiringPi. Програм­мы, которые поставляются в двух вариантах, — например, leds-rg.py и leds-wp.py, запускаются каждая с помощью своего пакета. Желательно, чтобы в комплекте присутствовали оба пакета, потому что ни один из них все еще не имеет полностью законченного набора возможностей, но в большинстве случаев возможности одного перекрывают недостатки другого. Так, слабостью пакета RPi.GPIO является отсутствие поддержки аппаратного PWM (широтно-импульсного модулятора), используемого в программе для управления двигателями. Слабостью пакета WiringPi яв­ляется отсутствие возможности управления подтягивающими резисторами, необходимыми для правильного использования кнопок. Программы, ориентированные на пакет RPi.GPIO, вызываются командой: fiiename-rg.py, а те, которые использу­ют пакет WiringPi, командой: filename-wp.py.

Вот список всех тестовых программ:

* buttons-rg.py — программа кнопок для RPi.GPIO;

* leds-rg.py — программа светодиодов для RPi.GPIO;

* leds-wp.py — программа светодиодов для WiringPi;

* butled-rg.py — программа кнопок и светодиодов для RPi.GPIO;

* motor-rg.py — программа мотора с использованием программного PWM и RPi.GPIO;

* motor-wp.py — программа мотора с использованием аппаратного PWM и WiringPi;

* ocol-rg.py — программа переключения реле для RPi.GPIO;

* ocol-wp.py — программа переключения реле для WiringPi;

* atod.py — тест аналого-цифрового преобразователя (A/D) с использованием SPI и модуля spidev;

* dtoa.py — тест цифроаналогового преобразователя (D/A) с использованием SPI и модуля spidev;

* dad.py — тест для обоих преобразователей (D/A и A/D) с использованием SPI и модуля spidev;

* potmot.py — тест с A/D и двигателем с использованием WiringPi и модуля spidev.

Буферизированные порты ввода/вывода

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

Рассмотрим как термины "вход" и "выход" применяются к платам Gertboard и Raspberry Pi. В режиме входа c Raspberry Pi на плату Gertboard через порты GPIO осуществляется вывод данных, а в режиме выхода с платы Gertboard Raspberry Pi должен быть настроен на ввод данных. Важно помнить об этом и не путать уста­новку перемычек платы Gertboard — при включенном режиме выхода из Gertboard порты на Raspberry Pi включаются на вход.

На рис. 6.26 показана схема установки перемычек портов I/O платы Gertboard с 4 по 12.

Треугольными символами на схеме обозначены буферы, которые выдают логиче­ские значения низкого и высокого уровней в направлении, указываемом треуголь­ником. Чтобы порты функционировали в качестве входа, установите входную пе­ремычку в Raspberry Pi, как показано на схеме с пометкой input. При этом поток данных идет от платы к компьютеру. Чтобы порты функционировали в качестве выхода, необходимо установить выходную перемычку output, и поток данных пой­дет от Raspberry Pi к плате. Если по ошибке или иной причине будут установлены сразу обе перемычки, то это не вызовет неисправности, но порт не будет правильно работать.

Светодиоды

Во входных и выходных режимах светодиод показывает, что на штырьке-выводе I/O присутствует логический уровень. Светодиод будет светиться, если высокий уровень присутствует на выводе, и не будет светиться при низком уровне. Сущест­вует и третий вариант для использования этого порта — когда ни одна из входных и выходных перемычек не установлена. В этом случае порт может быть использо­ван в качестве простого логического детектора, который подключается к любой активной точке с напряжением 0 В либо 3,3 В, а индикатор покажет, какой уровень будет в выбранной точке.

Резистор 10 кОм, включенный в цепь питания 3V3 (см. на рис. 6.26 справа) — подтягивающий. Если бы его не было, светодиод включался бы при любой минималь­ной электрической наводке или при случайном касании рукой вывода. Установка подтягивающего резистора предотвращает такое нештатное поведение.

Между входным буфером и выводами GPIO Raspberry Pi включен ряд ограничивающих резисторов, что необходимо для защиты процессора BCM2835, установ­ленного на Raspberry Pi, в случае, если пользователь случайно оставит входную пе­ремычку на месте, а с борта компьютера придет управляющий сигнал, посланный запущенной программой. Тогда нагрузкой вывода процессора BCM2835 и окажется ограничивающий резистор 1 кОм, и никакие элементы не выйдут из строя.

Кнопки

На плате Gertboard расположены три кнопки, присоединенные к портам 1, 2 и 3. Схема этих портов показана на рис. 6.27. Эта схема, по существу, та же, что и на рис. 6.26, только с добавлением кнопочного переключателя и резистора с левой стороны. Когда кнопка нажата, вывод порта Raspberry Pi подключается к "земле" через резистор и получает низкий логический уровень.

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

Тестирование кнопок

Для проверки работы кнопок существуют тестовые программы — например, программа на Python под названием buttons-rg.py. Чтобы запустить этот тест на плате Gertboard, должны быть установлены соединения, как показано на рис. 6.28.

Так, необходимо соединить проводниками и перемычками штырьки-контакты B1, B2, B3 в разъеме J3 и контакты портов GPIO: GP25, GP24 и GP23 — в разъеме J2 соответственно. Таким образом GPIO25 будет считывать состояние левой кнопки, GPIO24 — состояние средней, а GPIO23 — состояние правой. Перемычки на сто­роне "out" буфера U3: U3-out-B1, U3-out-B2 и U3-out-B3 — не являются обязатель­ными, но если они будут установлены, левые три светодиода загорятся при нажа­тии на кнопки и укажут текущее состояние кнопок.

Программа buttons-rg.py доступна только при использовании пакета RPi.GPIO (на данный момент функция включения подтягивающих резисторов в WiringPi для Python пока недоступна, а без этого кнопки не будут работать правильно). Содер­жимое файла buttons-rg.py представлено в листинге 6.12.

Листинг 6.12. Программа buttons-rg.py

Сначала программа импортирует модуль RPi.GPIO, необходимый для обработки портов GPIO. Затем команда:

GPIO.setmode (GPIO.BCM)

устанавливает схему нумерации для контактов, соответственно нумерации выводов процессора BCM. В результате номер штырька-контакта в коде Python становится числом, которое процессор BCM2835 на борту Raspberry Pi использует для обозначения контактов. В противном случае номера в коде Python будут ссылаться на штырек-контакт с номером в разъеме J1 — таким же, как номер его размещения в разъеме P1 на Raspberry Pi.

Следующие две строки устанавливают в портах 23-25 подтягивающие резисторы:

for i in range(23,26):

GPIO.setup(i, GPIO.IN, pull_up_down=GPIO.PUD_UP)

Как только пользователь подтверждает выданную ему информацию, устанавливаются начальные значения для переменных button_press и previous_status. Сле­дующий цикл — while — выполняется до тех пор, пока не произойдет 19 нажатий на кнопку. Для каждого круга этого цикла состояние каждой кнопки считывается и сохраняется в списке status_list. Если кнопка не была нажата, то в файле сохраня­ется значение 0, если кнопка была нажата — сохраняется значение 1. Все величины файла status_list проверяются на соответствие в previous_status. Если изменить эту строку так:

if current status != previous status:

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

Цикл while заключен в блоке try:

try:

<while block>

except KeyboardInterrupt:

Это даст возможность корректного выполнения команды сброса портов, если ранее была нажата комбинация клавиш <Ctrl>+<C>. При нормальном же завершении программы после 19 нажатий кнопки порты будут сброшены в любом случае. Од­нако если бы вы не включили в блок try прерывание с клавиатуры except, то нажа­тие комбинации клавиш <Ctrl>+<C> закрыло бы программу, но оставило порты открытыми. И если бы вы попытались использовать порты снова, это дало бы ошибку, т. к. в них уже имелись бы какие-то значения.

Тестирование светодиодов

Программы на языке Python тестирования светодиодов называются leds-rg.py и leds-wp.py. При настройке платы Gertboard для выполнения этого теста необходимо установить проводники и перемычки согласно схеме, приведенной на рис. 6.29. Каждый порт I/O подключен в качестве выходного, так что все перемычки устанав­ливаются как OUT. Проводники используются для подключения всех контактов GP, располагающихся в разъеме J2, и всех контактов B в разъеме J3: GP25 соединя­ем с B1, GP24 — с B2, GP23 — с B3, GP22 — с B4, GP21 — с B5, GP18 — с B6, GP17 — с B7, GP11 — с B8, GP10 — с B9, GP9 — с B10, GP8 — с B11 и GP7 — с B12. Все 12 контактов GP слева соединены с контактами В за исключением про­пущенных GP14 и GP15. Эти два контакта используются в Linux в режиме UART, так что лучше их в данной операции не задействовать.

Тест светодиодов доступен как для RPi.GPIO, так и для WiringPi на языке Python. Единственное различие между программами leds-rg.py и leds-wp.py — это способ нумерации выводов портов GPIO в разных ревизиях Raspberry Pi. Рассмотрим скрипт leds-rg.py, содержимое которого представлено в листинге 6.13.

Листинг 6.13. Скрипт leds-rg.py

Прежде всего проверяем версию платы Gertboard и определяем список портов ports для нашей ревизии. Затем настраиваем порты для вывода, руководствуясь списком ports. Функция led_drive () управляет зажиганием-гашением светодиодов, для которой имеется три аргумента: reps, multiple и direction:

* reps определяет, сколь долго запускать процессы (1 или 3 в этой демонстрации);

* multiple определяет, возможно или нет выключение предыдущего перед вклю­чением следующего светодиода (значение 1 оставляет включенными несколько светодиодов);

* direction определяет направление, в котором следует листать список ports (ports — вперед, ports_rev — обратно).

В тексте программы содержится восемь вызовов функции led_drive (). Все они за­ключены в блоках try и except. Это гарантирует, что при выходе через комбинацию клавиш <Ctrl>+<C> значения портов GPIO будут сброшены (cleanup). Это позволя­ет избежать ложных включений, и порты смогут свободно использоваться другой программой.

Драйвер с открытым коллектором

Плата Gertboard располагает шестью портами, организованными на микросхеме ULN2803A и предоставляющими собой драйверы с открытым коллектором. Они служат, чтобы включать и выключать устройства, — в частности те, которые рассчитаны на питание от внешнего источника с различными напряжениями и токами большими, чем может позволить себе плата Gertboard. Схема подключения одного из шести блоков драйвера с открытым коллектором представлена на рис. 6.30.

Для включения устройств драйвер с открытым коллектором замыкает цепи на пла­те на стороне внешних схем на "землю", таким образом давая им сигнал. Микро­схема ULN2803A может выдержать напряжение до 50 В и ток до 500 мА на каждом из своих портов. Каждый порт драйвера имеет встроенный диод защиты.

Common — это провод цепи питания. Как следует из его названия, он питает сразу все блоки драйвера с открытым коллектором. Этот провод на плате Gertboard ни к чему не подключен. Как и все устройства управления, драйвер с открытым коллектором с помощью точки Raspi может быть подключен к портам GPIO или к выходам контроллера ATmega — например, для включения реле, двигателей либо иных управляемых устройств.

На рис. 6.28 и 6.29 контакты, соответствующие точкам Raspi, — это контакты с метками с RLY1 по RLY6 в разъеме J4. Контакты, соответствующие common, от­мечены как RPWR в разъеме на правом краю платы, а контакты, соответствующие OUT, помечены RLY1 по RLY6 в разъемах с J12 по J17.

Контроллер двигателя

На борту платы Gertboard установлен контроллер двигателя, собранный на микросхеме ROHM BD6222HFP. Контроллер двигателя способен работать с коллектор­ными электродвигателями постоянного тока, рассчитанными на напряжение не бо­лее 18 В и ток не более 2 А. Контроллер имеет два контакта-входа А и В, обозна­ченные на плате как MOTA и MOTB (см. рис. 6.28 и 6.29). Контроллер двигателя управляется высоким и низким логическими уровнями по шаблону, приведенному в табл. 6.2. Скорость вращения двигателя контролируется путем применения сигна­ла широтно-импульсной модуляции (ШИМ).

Контроллер двигателя находится в верхней части платы. Он имеет колодку с винтовыми зажимами-клеммами для крепления проводов двигателя и внешнего источ­ника питания, а также два штырька-контакта для подачи сигналов управления в разъеме J5, находящемся чуть выше контактов GP4 и GP1 в разъеме J2. Штырьки- контакты с маркировкой MOTA и MOTB в разъеме J5 являются логическими вхо­дами низкого либо высокого уровня. Винтовые клеммы в верхней части платы, по­меченные как MOTA и MOTB, представляют собой выходы контроллера двигателя. Для питания используется внешний источник, подключаемый с помощью винтовых клемм, защищенных плавким предохранителем F1 на 2 А. Предохранитель здесь требуется потому, что для работы двигателя необходимы ток и напряжение пита­ния большие, чем может обеспечить плата Gertboard. Выход напряжения на винто­вые клеммы MOTA и MOTB возможен только при наличии соответствующего мо­дулируемого логического сигнала на штырьках-контактах разъема J5, помеченных как MOTA и MOTB.

Для включения двигателя в любом направлении без изменения скорости, необходимо выбрать пару свободных портов GPIO, установить электрическое соединение между ними и входами контроллера двигателя МОТА и MOTB и подать на них сигналы, соответствующие табл. 6.2.

С помощью ШИМ можно контролировать количество времени выхода высокого уровня по сравнению с временем низкого уровня. Выход импульсов широтно­импульсного модулятора, собранного на базе процессора BCM2835, установленно­го на борту Raspberry Pi, можно получить на выходе порта GPIO18, включив альтернативную функцию 5. Этот выход порта соединен с одним из входов контролле­ра двигателя — например, с входом МОТА, куда и подается прямоугольный им­пульс, при этом на вход МОТВ подается постоянный высокий или низкий уровень. Таким образом и регулируются режимы работы двигателя.

Тестовые программы motor-rg.py и motor-wp.py существенно отличаются, потому что пакет RPi.GPIO пока еще не поддерживает аппаратный широтно-импульсный модулятор, тогда как WiringPi для Python поддерживает, хотя об этом прямо и не говорится. Соответственно, программа motor-rg.py в версии для RPi.GPIO основана на программно-организованном ШИМ.

Программа motor-rg.py (листинг 6.14) после импорта необходимых модулей опреде­ляет используемые порты GPIO 17 и 18, количество раз запуска каждого цикла — Reps, время рабочего цикла ШИМ — Hertz и частоту периодичности циклов двигателя — Freq. Затем порты настраиваются как выходы и устанавливаются в выклю­ченное состояние  OFF (0). Тем и определяется функция run_motor(Reps, pulse_width, port_num, time_period) , которая контролирует включение и выклю­чение портов GPIO в определенный период времени: порт port_num включается на время pulse_width, затем отключается на время time_period. Все это повторяется Reps раз.

Основной цикл в функции run_motor () находится внутри блока try: except: . Это важно для безопасности, поскольку обеспечивает правильное выключение двигате­ля прерыванием с клавиатуры. Функция run_motor () вызывается множество раз функцией run loop (). Каждый цикл в 400 повторений — это всего один шаг повышения или понижения скорости вращения двигателя. 400 повторений при частоте 2000 герц занимают лишь 0,2 секунды.

Рассмотрим параметры функции run_loop (startloop, endloop, step, port_num, printchar) подробнее:

* startloop и endloop выделяют время в % для коммутируемого порта и запускают либо останавливают цикл;

* step — размер приращения для каждого последующего цикла;

* port_num — порты, которые мы переключаем: 17 или 18;

* printchar — индикация ускорения/замедления с помощью количества знаков "+" или "-".

Как уже отмечено, функция run_loop () вызывает функцию run_motor (), заставляя ее повторяться 400 циклов для каждого набора определенного значения. После того как функции определены, инструкции соединений выведены, компьютер ждет на­жатия клавиши <Enter>, подтверждающей, что пользователь готов. Затем функция run loop () вызывается четыре раза для управления скоростью двигателя от 5 до 95 % в каждом из направлений. После этого оба порта выключаются и сбрасы­ваются.

Листинг 6.14. Программа motor-rg.py

Теперь рассмотрим программу motor-wp.py (листинг 6.15). Raspberry Pi имеет один доступный аппаратный ШИМ-порт — GPIO18. Мы воспользуемся портом 17 — для управления направлением вращения двигателя и портом 18 — для выдачи прямоугольного импульса. Первая часть программы импортирует необходимые модули. После инициализации пакета WiringPi порт 18 устанавливается в режим ШИМ с помощью инструкции:

wiringpi.pinMode(18,2)

а порт 17 настраивается на нормальный выход. Затем оба порта устанавливаются в 0 (off) . Далее инструкция подключений выводится на экран, и компьютер ждет команды пользователя. Когда пользователь готов, программа определяет три функ­ции, которые используются повторно:

* display (printchar) — обрабатывает правильную индикацию ускоре­ния/замедления двигателя;

* reset_ports () — производит сброс портов при выходе из программы. Это важ­но для программы управления двигателем в пакете;

* loop (start_pwm, stop_pwm, step, printchar) ---------------------  обслуживает    основной    цикл ШИМ.

В момент start_pwm — ШИМ принимает значения от 0 до 1024 в начале цикла. В момент stop_pwm — ШИМ принимает значение от 0 до 1024 в конце цикла. Пара­метр step — приращивает/уменьшает значение для каждого последующего цикла.

Параметр printchar — оператор для отображения режима ускорения или замедле­ния вращения двигателя. Основная часть программы содержит четыре вызова loop (), чтобы продемонстрировать ускорение и замедление в каждом из двух раз­личных направлений вращения с короткими, но ощутимыми, паузами между цик­лами. Время паузы определяется в rest = 0,013 (0,013 секунды). Когда значение порта 17 равно 0, двигатель вращается в одном направлении. Когда значение порта 17 равно 1, он вращается в противоположную сторону. Как обычно, в основной части программы содержится конструкция try: except:                                                       , предусматривающая включение блокировки и сброса значения порта для обеспечения безопасности пе­ред выходом с применением прерывания с клавиатуры.

Листинг 6.15. Программа motor-wp.py

Аналого-цифровые и цифроаналоговые преобразователи

На плате Gertboard установлен цифроаналоговый преобразователь (D/A) от компании Microchip, собранный на микросхеме MCP48x2. Это устройство производится в трех различных вариантах: 8-, 10- или 12-битном (разрядном). Какой из вариантов установлен именно на вашей плате, можно узнать из маркировки на корпусе мик­росхемы. Для этого посмотрите очень внимательно на маленький чип, обозначен­ный U10. На его корпусе должен быть виден номер 48x2, где вместо х могут стоять числа: 0, 1 или 2. Если х равен 0, то преобразователь 8-разрядный, если 1 — то 10-разрядный, а если 2 — то 12-разрядный. Все эти варианты исполнения микро­схемы совместимы и имеют одинаковое расположение и счет выводов. Программа, которая работает с D/A, предполагает, что записывает в 12-битный чип, поэтому важно указывать соответствующие значения. Максимальные выходное и входное напряжения D/A — 2,04 В. Аналоговые выходы двух каналов подключены к кон­тактам, помеченным как DA0 для канала 0 и DA1 — для канала 1 в разъеме J29 на левом краю платы. Контакты, расположенные рядом, подключены к "земле" (GND).

На плате Gertboard используется 10-битный аналого-цифровой преобразователь (A/D), собранный на микросхеме MCP3002. Он поддерживает 2 канала с частотой дискретизации около 72K операций в секунду (sps). Максимальное значение — 1023 — возможно, когда входное напряжение равно 3,3 В. Аналоговые входы двух каналов AD0 и AD1 находятся в разъеме J28. Рядом с этими выводами расположе­ны контакты "земли" (GND).

Тестирование D/A и A/D

Как сказано в руководстве на микросхему MCP4802, значение напряжения (В) на выходе Vout вычисляется по формуле:

VoUt = (Din/2x) х 2,048, где x = 8, 10, 12 — разрядность микросхемы MCP4802.

Выход Vout для канала 0 представлен контактом DA0 в разъеме J29, а для кана­ла 1 — DA1.

Для проверки работы цифроаналогового преобразователя (D/A) потребуется вольт­метр или мультиметр. Программа тестирования для Python называется dtoa.py. Что­бы настроить плату Gertboard для этого теста, необходимо установить перемычки на контакты портов GP11, GP10, GP9, GP7 и на контакты шины SPI, находящиеся над ними.

Подключить мультиметр надо следующим образом: черный отрицательный провод должен быть подсоединен к GND. Для этого можно использовать любой из штырь­ков, помеченных как GND. Красный, положительный, провод должен быть под­соединен к DA0 (для проверки D/A канала 0) или DA1 (для проверки D/A канала 1). Переключите мультиметр и установите его для измерения постоянного напряже­ния. Схема соединений показана на рис. 6.31.

Содержимое файла dtoa.py представлено в листинге 6.16. Цифроаналоговый преобразователь (D/A) управляется с помощью записи двоичных чисел (16 битов в це­лом) через шину интерфейса SPI. Программа для модуля Python называется spidev и использует шину SPI для связи. Мы должны дать spidev двоичные 10-битные значения, которые он преобразует в 8-битный двоичный код, впоследствии переда­ваемый в D/A. D/A выдает напряжение в соответствии с цифровым значением на входе. Если на входе цифровое значение 0, то это соответствует 0 В, а если значе­ние 255, то на выходе 2,048 В, и это линейная зависимость между ними, так что цифровое значение 128 должно соответствовать напряжению 1,02 В.

Мы посылаем в D/A заранее определенные значения, которые хранятся в двух изменяемых списках:

* num_list [] — содержит первый байт данных (отличается для каждого канала);

* common [] — содержит второй байт данных (одинаковые для каждого канала).

Пользователь выбирает канал, а затем основной цикл принимает первый номер из каждого списка и сливает byte1 с byte2. Затем он посылает их в D/А, который сразу же выдает соответствующее напряжение на выходе до нажатия клавиши <Enter>. Цикл проходит по всем пяти значениям, установленным в D/A, и дожидается нажа­тия клавиши <Enter>. Оба канала сбрасываются в ноль в конце программы.

Листинг 6.16. Программа dtoa.py

Программа для теста аналого-цифрового преобразователя называется atod.py. Чтобы запустить этот тест, источника напряжения на аналоговом входе не требуется. Проще всего использовать потенциометр (переменный резистор). Два конца потенциометра связаны с одной стороны с высоким уровнем 3,3 В (который можно по­лучить из любого контактного разъема с отметкой 3V3), а с другой стороны    с низким уровнем, или GND. Средний конец связан со входом AD0 (для канала 0) или AD1 (для канала 1). Для использования шины SPI соединительные провода должны быть установлены на контакты GP11, GP10, GP9, GP8 и подключены к контактам шины SPI, которые находятся над ними, как показано на рис. 6.32.

Содержимое файла atod.py представлено в листинге 6.17. Пользователь выбирает канал, который будет использоваться аналого-цифровым преобразователем (A/D), как и написано в комментариях к программе. Функция get_adc (channel) использу­ет программу spidev для считывания A/D. Эта функция получает три байта данных и извлекает результат — число от 0 до 1023, где 0 означает 0 В, а 1023 — 3,3 В. Главный цикл выполняется 600 раз с задержкой sleep в 0,05 с, поэтому выполнение программы занимает около 30 секунд: 600x0,05. Во время каждой итерации цикла программа считывает значение из A/D и отображает результат количеством симво­лов "#" пропорционально считанному значению, которое зависит от положения движка потенциометра. Для запуска этого процесса служит функция display(char, reps, adc_value, spaces). Во время работы программы перемещение движка потенциометра приводит к изменениям как цифровых величин, так и количества отображаемых на дисплее символов "#".

Листинг 6.17. Программа atod.py

Примечание

Коды скриптов этого раздела вы найдете в папке glava_06\GB_Python сопровождающего книгу электронного архива (см. приложение).