Кафедра компьютерных наук и технологий

  1. Шаг первый: обновление ядра
  2. Шаг второй: подключение датчика температуры
  3. Шаг третий (A): считывание датчика с терминала
  4. Шаг третий (B): чтение температуры с Python
  5. Шаг четвертый: написать сценарий для распечатки температуры.
  6. Шаг пятый: подключение светодиода
  7. Шаг шестой: Включение светодиода
  8. Шаг седьмой: есть более легкий путь!
  9. Шаг восьмой: подключение кнопки
  10. Шаг девятый (A): Проверка нажатия кнопки из терминала
  11. Шаг девятый (B): проверка нажатия кнопки с использованием Python
  12. Шаг десятый: написание программы регистрации температуры
  13. Приложение 1: Имя файла данных
  14. Приложение 2: Замена выводов GPIO
  15. Приложение третье: ведение журнала с переменной скоростью
  16. Где дальше?

В этом уроке мы будем строить схему для подключения датчика температуры к нашему Raspberry Pi и писать программу для считывания данных датчика. Схема, которую мы построим, будет подключаться к Raspberry Pi с помощью выводов GPIO.

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

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

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

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

Шаг первый: обновление ядра

  • Первым шагом является изменение того, откуда обновляется наш Pi, путем редактирования текстового файла. Нам нужно открыть файл /etc/apt/sources.list.d/raspi.list от имени root, поэтому введите:
    sudo leafpad /etc/apt/sources.list.d/raspi.list
  • Теперь измените строку в этом файле так, чтобы он читал «deb http://archive.raspberrypi.org/debian/ wheezy main untested», затем сохраните и закройте файл.
  • Далее выполните следующие команды:
    apt-get update
    apt-get upgrade

То, что мы делаем здесь, это заставляет Pi обновляться, используя самое последнее ядро. Ядро - это бит программного обеспечения самого низкого уровня, который устанавливает связь между фактическим оборудованием и всем остальным программным обеспечением, которое может работать. Как только Pi узнает, что может обновиться из этого совершенно нового места, мы обновляем ядро. Это новое ядро ​​имеет весь дополнительный код, необходимый для доступа к датчику температуры, который мы будем использовать.

Шаг второй: подключение датчика температуры

  • Выключите Pi - обычно плохая идея подключать провода, когда через контакты проходит электричество.
  • Получить:
  • Спаяйте части ленточного соединителя вместе и прикрепите соединитель ленточного кабеля к Pi и макетной плате.
  • Подсоедините контакт 3 на датчике к контакту 3,3 В GPIO (обозначен 3V3 на разъеме AdaFruit).
  • Подсоедините контакт 1 к заземленному контакту GPIO (обозначен GND на разъеме AdaFruit).
  • Подсоедините контакт 2 к контакту 4 GPIO (обозначен # 4 на разъеме AdaFruit).
  • Поместите резистор 4,7 кОм между контактом 2 и 3 датчика температуры.
  • Включите Pi, а затем приложите палец к датчику. Если он подключен неправильно, то через секунду или две он сильно нагреется, и в этом случае выключите Pi после загрузки и подождите некоторое время (после того, как я это сделал, через 10 минут он все еще оставался горячим). ), чтобы он остыл, а затем выньте датчик и снова установите его обратно в правильном направлении.
В этом уроке мы будем строить схему для подключения датчика температуры к нашему Raspberry Pi и писать программу для считывания данных датчика

Разъем для ленточного кабеля AdaFruit избавляет нас от необходимости подключать провода непосредственно к плате Raspberry Pi, так как это было бы очень неудобно. Он также имеет лучшую маркировку на выводах GPIO, что облегчает работу с ним.

Датчик температуры, который мы здесь используем, DS18S20, имеет три ножки. Два из этих выводов помещают датчик в цепь между выводом высокого напряжения и землей. Это соединение обеспечивает питание датчика для измерения температуры. Третий контакт соединяется с контактом GPIO, и именно с этим соединением мы можем связываться с датчиком. Резистор, который мы поместили между этим выводом данных и выводом высокого напряжения, называется так называемым подтягивающим резистором - если ветвь данных не заземлится для посылки 0 вдоль провода, его напряжение на проводе будет до 3,3 В. Это упрощает связь датчика с нашим Pi, так как для отправки сигнала 1 он вообще ничего не должен делать.

Шаг третий (A): считывание датчика с терминала

Первым шагом здесь было запустить команду modprobe. Эта команда может загружать отдельные модули, которые делают определенные вещи в ядре, поэтому мы можем их использовать. Если вы не хотите вводить команды modprobe при каждом запуске Pi, вам нужно будет сказать Linux, что вы хотите, чтобы эти модули загружались автоматически при запуске. Это можно сделать, открыв файл / etc / modules - для этого вам нужно быть пользователем root, поэтому введите sudo leafpad / etc / modules в терминал. Теперь добавьте строки «w1-gpio» и «w1-therm» в конец этого файла, сохраните его и закройте.

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

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

Шаг третий (B): чтение температуры с Python

  • Откройте терминал и введите python.
  • В командной строке python IDLE введите команды ниже, игнорируя строки, начинающиеся с # - они объясняют, что делают команды:
    # Откройте файл, который мы просматривали ранее, чтобы python мог видеть, что в нем. Замените серийный номер, как и раньше.
    tfile = open ("/ sys / bus / w1 / devices / 10-000802824e58 / w1_slave")
    # Прочитайте весь текст в файле.
    text = tfile.read ()
    # Закройте файл сейчас, когда текст прочитан.
    tfile.close ()
    # Разделите текст новыми строками (\ n) и выберите вторую строку.
    secondline = text.split ("\ n") [1]
    # Разбейте строку на слова, ссылаясь на пробелы, и выберите 10-е слово (считая от 0).
    temperaturedata = secondline.split ("") [9]
    # Первые два символа - «t =», поэтому избавьтесь от них и преобразуйте температуру из строки в число.
    температура = плавающая (температура данных [2:])
    # Поместите десятичную точку в нужном месте и отобразите ее.
    температура = температура / 1000
    температура печати

В этом разделе довольно много команд Python, которые могут быть незнакомы. В терминале Python IDLE введите help (что-то), и отобразится описание того, что было заключено в квадратные скобки, и некоторая общая информация о том, что можно сделать с помощью команды. Например, в tfile.read () существуют также tfile.readline () и tfile.readlines (), которые, как следует из названия, делают разные вещи. Если присвоение переменной (температура = бит) не включено в строки, написанные выше, будет выведен результат метода .split.

В командах только сейчас текст медленно разбивается до тех пор, пока не останутся только значения температуры, с несколькими строками кода. Это много строк кода не требуется, температураdata = text.split ("\ n") [1] .split ("") [9] также будет работать, или разделение на пробелы с начала, а не переводы строк. Однако код может быть сложнее читать, если он помещен в одну строку. Эта операция может быть выполнена быстрее - поиграйте с ней, и если более быстрый путь станет очевидным, может быть, одноклассник может решить, что он делает?

Увидеть Вот для моего примера кода.

Шаг четвертый: написать сценарий для распечатки температуры.

  • Установите текстовый редактор, например Geany или SciTE, или используйте предустановленный Leafpad или аналогичный.
  • Откройте редактор и скопируйте код, написанный выше (или версию с другим предложенным разделением).
  • Сохраните файл как Temperature.py в / home / pi.
  • Откройте терминал и запустите python Temperature.py. Программа должна вывести температуру как раньше.

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

Здесь рекомендуется установить другой текстовый редактор для написания кода. Причина этого заключается в том, что текстовый редактор по умолчанию - Leafpad, с которым поставляется Pi, на самом деле не предназначен для написания кода. Если вы откроете свой скрипт Python в IDLE и в Leafpad, вы увидите, что в IDLE добавлен цвет к коду - это называется подсветкой синтаксиса. Это то, что делают почти все текстовые редакторы, предназначенные для написания кода, потому что это облегчает просмотр того, что происходит в программе. SciTE или Geany рекомендуются в этом уроке. SciTE немного быстрее открывает файлы и выглядит более простым для начала, в то время как Geany имеет гораздо больше функций, которые становятся полезными, когда ваша программа становится немного длиннее, например, вывод списка всех имен переменных в вашей программе, что позволяет легче запомнить, какие имена были использованы.

Шаг пятый: подключение светодиода

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

Здесь мы создали цепь от одного из выводов GPIO, через светодиод и резистор, до земли. С помощью Pi мы можем включить определенный вывод GPIO, чтобы он имел высокое напряжение, и ток будет течь через светодиод и резистор. Резистор, который мы вставили, останавливает слишком большой ток, который может нагреть светодиод настолько, что он перегорит.

Шаг шестой: Включение светодиода

  • Включи Пи.
  • Откройте корневой терминал из меню или запустите sudo su в обычном терминале.
  • Теперь введите эти команды, где «18» в этом примере заменяется на любой вывод, к которому подключен светодиод:
    cd / sys / class / gpio /
    эхо "18"> экспорт
    cd gpio18
    эхо "out"> направление
    echo "1"> значение
  • Теперь светодиод должен быть включен.
  • Чтобы выключить светодиод, введите:
    echo "0"> значение
    CD ..
    эхо "18"> неэкспорт

Здесь мы открыли корневой терминал для управления светодиодом. Почему мы должны были сделать это здесь, а не когда мы работали с нашим датчиком температуры? С датчиком температуры все, что мы могли сделать, это попросить температуру, которая довольно безвредна. С помощью светодиода мы хотели что-то изменить в аппаратном обеспечении (сделать вывод GPIO, который мы выбрали, выходным), что может привести к тому, что произойдет что-то плохое, если мы изменили что-то, чего у нас не должно быть, или изменили неправильный номер вывода. С Raspberry Pi он спроектирован таким образом, что вы ничего не можете сломать, просто изменив неправильный вывод GPIO, но ограничение осталось от более дорогих компьютеров, которые легче сломать.

После того, как мы открыли корневой терминал, сначала мы должны сказать Pi, что мы хотим сделать что-то с определенным выводом GPIO, что мы делаем с помощью echo, чтобы записать номер вывода в файл экспорта. Пи замечает, что мы сделали это, и создает папку для этого пина, чтобы мы могли контролировать его. Затем мы сообщаем Pi, что хотим, чтобы этот вывод был выходным, снова используя echo, чтобы мы могли включать и выключать светодиод. Запись числа «1» в файл значений приводит к включению вывода, так что ток выводится из этого вывода. После того, как наш светодиод работает, мы выключаем его, отображая «0», а затем сообщаем Pi, что мы закончили работу с этим выводом, записывая номер вывода в файл неэкспорта.

Мы только что видели, как включать и выключать светодиод с помощью терминала, так что теперь пришло время заставить его работать с Python. Программа должна записать в файл. Вот пример записи «Hello» в файл с именем «example». Построй на этом.

# Откройте файл и напишите в него, следовательно, "w"
f = open ("пример", "w")
f.write ( "привет")
f.close ()

Запустите эту программу в терминале, используя sudo python по причинам, описанным выше. Он должен включить светодиод.

Увидеть Вот для моего примера кода.

Шаг седьмой: есть более легкий путь!

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

  • Установите пакет с помощью sudo apt-get install python-rpi.gpio в терминале.
  • Запустите Python от имени пользователя root с помощью sudo python и введите:
    импортировать RPi.GPIO как GPIO
    # Используйте номера контактов с платы ленточного кабеля.
    GPIO.setmode (GPIO.BCM)
    # Установите вывод, который вы используете (например, «18») в качестве вывода.
    GPIO.setup (18, GPIO.OUT)
    # Включите штифт и увидите, что светодиод загорается.
    GPIO.output (18, GPIO.HIGH)
    Выключите контакт, чтобы выключить светодиод.
    GPIO.output (18, GPIO.LOW)

Эта библиотека, которую мы установили, является всего лишь фрагментом кода, на этот раз написанным на языке программирования C, который скрывает все детали того, что необходимо сделать, чтобы включить и выключить выводы GPIO. Когда библиотека Python для команды GPIO.setup (18, GPIO.OUT) исчезает и выполняет все то, что мы делали раньше - запись номера пина в файл экспорта и запись «в» в файл, называемый direction, но они просто спрятано

Команда setmode сообщает библиотеке, что мы маркируем наши выводы, как они находятся на плате ленточного кабеля. Плата относится к контактам с точки зрения того, что они делают, поэтому контакты имеют метки, такие как «3V3», «GND», «5V0». Альтернатива, которая была бы сделана с помощью GPIO.setmode (GPIO.BOARD), состоит в том, чтобы нумеровать булавки таким же образом, как нумерация домов на улице - булавки на одной стороне имеют номера 1,3,5 полностью до 25, а контакты на другой стороне имеют номера от 2,4,6 до 26.

Шаг восьмой: подключение кнопки

  • Здесь понадобится нажимная кнопка и 1 кОм.
  • Выберите другой свободный входной контакт и подключите этот контакт к одной стороне кнопки, а другую сторону кнопки - к контакту 3,3 В.
  • Поместите резистор между входным контактом и контактом заземления на Pi.

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

Шаг девятый (A): Проверка нажатия кнопки из терминала

Как и в случае со светодиодами, мы должны сообщить Pi, что мы хотим сделать что-то с определенным выводом GPIO, что мы делаем, используя echo, как и раньше. Затем мы сообщаем Pi, что мы хотим, чтобы этот вывод был входным выводом, используя эхо «in», а не «out», чтобы мы могли измерить, нажата кнопка или нет. Когда мы читаем файл «value», мы проверяем, высокий или низкий ввод (1 или 0 соответственно). Наконец, «неэкспортируйте» булавку, как раньше.

Шаг девятый (B): проверка нажатия кнопки с использованием Python

  • Запустите Python от имени пользователя root и введите:
    импортировать RPi.GPIO как GPIO
    # Используйте номера контактов с платы ленточного кабеля
    GPIO.setmode (GPIO.BCM)
    # Установите этот вывод как ввод.
    GPIO.setup (17, GPIO.IN)
    # Кнопка нажата или нет?
    GPIO.input (17)
    # Удерживая кнопку, запустите команду еще раз. Вывод должен быть «верным».
    GPIO.input (17)

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

Увидеть Вот для моего примера кода.

Шаг десятый: написание программы регистрации температуры

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

  • Нам нужен еще один светодиод и еще один резистор 220 Ом. Два светодиода будут использоваться, чтобы показать, когда наша программа готова начать измерение температуры и когда она фактически записывает ее в файл. Чтобы сделать это более очевидным, здесь пригодился бы другой цветной светодиод.
  • С этими дополнительными частями подключите светодиод к другому свободному контакту, как и первый светодиод.
  • Откройте текстовый редактор и выполните следующие действия:
    • Импортируйте библиотеку RPi.GPIO.
    • Установите три вывода GPIO (кнопку и два светодиода) в качестве входа и выхода.
    • Включите один из светодиодов, чтобы указать, что мы готовы начать регистрацию.
    • Используйте код из предыдущего упражнения, чтобы проверить, нажата ли кнопка, и подождите, пока кнопка не будет нажата.
    • Когда кнопка нажата, мы хотим, чтобы наш первый светодиод выключился, а другой загорелся, чтобы указать, что наш Pi теперь принимает данные.
    • Затем откройте файл, который мы можем написать, чтобы дать нам место для размещения данных.
    • Добавьте еще один цикл while, чтобы дождаться повторного нажатия кнопки, и в цикле считайте температуру так же, как мы делали это раньше.
    • Вместо того, чтобы печатать температуру, мы запишем температуру в файл, который мы открыли ранее. Одно из изменений, которое нам нужно будет сделать из того, как мы научились писать в файлы ранее, заключается в том, что теперь мы хотим, чтобы каждое значение температуры находилось на новой строке. Это можно сделать, добавив "\ n" в конец строки, которую мы пишем, например, str (температура) + "\ n".
    • Когда существует последний цикл while, мы хотим закрыть файл, как мы закончили с ним, и мы делаем это с помощью datafile.close (), и выключаем светодиод.

Увидеть Вот для моего примера кода.

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

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

Приложение 1: Имя файла данных

В сценарии всегда используется одно и то же имя файла, поэтому старые данные исчезают каждый раз, когда появляются новые. Имена файлов можно сделать уникальными с помощью «heatdata1.log», «Temperaturedata2.log», но более полезным способом является добавление к имени так называемой временной метки. Чтобы сделать это в Python:

  • Импортируйте модуль «время» в Python, узнайте текущее время для файла журнала и поместите его в удобную для чтения форму, затем добавьте его к имени файла, например, так:
    время импорта
    # Отображает время в формате год-месяц-день, час-минута-секунда.
    timestamp = time.strftime ("% Y-% m-% d-% H-% M-% S")
    # Соедините разные биты имени файла в один и откройте файл.
    filename = "" .join (["TemperatureData", отметка времени, ".log"])
    datafile = open (имя файла, "w", 1)

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

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

Вы также увидите, что команда для открытия файла получила дополнительную опцию, «1» в конце. Если вы запустите старый код, который у нас был, и при этом загляните в свой файловый браузер, вы заметите, что файл появляется, как только мы начинаем регистрировать, но в списке указан размер нулевых байтов, пока мы не нажмем кнопку, чтобы прекратить регистрацию. Это происходит потому, что Python хранит все данные в памяти где-то, и фактически только записывает их на SD-карту, когда вы закрываете файл. Проблема с таким поведением заключается в том, что, если бы мы внезапно отключили питание или прекратили запуск программы, мы потеряли бы все данные, которые собрали, потому что на карте ничего не было. Добавляя опцию «1» к нашей команде open, мы сообщаем Python, что мы хотим, чтобы он сохранял в памяти только одну строку текста за раз, и что он должен записывать каждый бит текста на SD-карту, когда линия заканчивается.

Увидеть Вот для моего примера кода.

Приложение 2: Замена выводов GPIO

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

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

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

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

Увидеть Вот для моего примера кода.

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

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

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

  • Поэтому в своем коде добавьте переменную, которая хранит время непосредственно перед тем, как вы прочитаете температуру, и в конце цикла while. Вы можете сравнить эти два раза, и, если разница меньше ожидаемого нами значения, заставьте программу ждать столько времени, сколько потребуется, чтобы восполнить разницу. В Python заставить вашу программу подождать некоторое время так же просто, как использовать команду sleep в модуле time, и указать для нее продолжительность времени, в течение которого вы хотите спать.

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

  • Замените одиночный режим сна циклом for, который будет работать в течение 0,1 секунды, однако для устранения разницы требуется много раз, и проверяйте нажатие кнопки после каждого небольшого сна. Если кнопка нажата, вы захотите использовать команду break для выхода из цикла for, но сначала установите для некоторой переменной значение True, чтобы мы могли проверить эту переменную во внешнем цикле while и выйти из нее, если она есть. Правда. Не забудьте определить эту переменную как False до начала цикла, чтобы не допустить путаницы в Python.
  • Ваш код для этого раздела, вероятно, будет выглядеть примерно так:
    if (time_2 - time_1) <measure_wait: no_of_sleeps = int (round ((measure_wait - (time_2 - time_1)) / 0.1))
    для меня в диапазоне (no_of_sleeps): time.sleep (0,1)
    если GPIO.input (BUTTON_GPIO_PIN):

    button_pressed = True
    перерыв

    если кнопка нажата:

    перерыв

Увидеть Вот для моего примера кода.

Где дальше?

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

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

Эта операция может быть выполнена быстрее - поиграйте с ней, и если более быстрый путь станет очевидным, может быть, одноклассник может решить, что он делает?
Почему мы должны были сделать это здесь, а не когда мы работали с нашим датчиком температуры?
Что хорошо работает, но что происходит, когда мы перемещаем вещи на доске?
Итак, как насчет того, чтобы исправить это правильно?
Где дальше?
Теперь у нас есть полная программа датчиков температуры, что мы можем делать дальше?