Читаем данные с датчика температуры DHT-11 на «голом» железе Arduino Uno ATmega328p используя только ассемблер
Попробуем на простом примере рассмотреть, как можно “хакнуть” Arduino Uno и начать писать программы в машинных кодах, т.е. на ассемблере для микроконтроллера ATmega328p. На данном микроконтроллере собственно и собрана большая часть недорогих «классических» плат «duino». Данный код также будет работать на практически любой demo плате на ATmega328p и после небольших возможных доработок на любой плате Arduino на Atmel AVR микроконтроллере. В примере я постарался подойти так близко к железу, как это только возможно. Для лучшего понимания того, как работает микроконтроллер не будем использовать какие-либо готовые библиотеки, а уж тем более Arduino IDE. В качестве учебно-тренировочной задачи попробуем сделать самое простое что только возможно — правильно и полезно подергать одной ногой микроконтроллера, ну то есть будем читать данные из датчика температуры и влажности DHT-11.
Arduino очень клевая штука, но многое из того что происходит с микроконтроллером специально спрятано в дебрях библиотек и среды Arduino для того чтобы не пугать новичков. Поигравшись с мигающим светодиодом я захотел понять, как микроконтроллер собственно работает. Помимо утоления чисто познавательного зуда, знание того как работает микроконтроллер и стандартные средства общения микроконтроллера с внешним миром — это называется «периферия», дает преимущество при написании кода как для Arduino так и при написания кода на С/Assembler для микроконтроллеров а также помогает создавать более эффективные программы. Итак, будем делать все наиболее близко к железу, у нас есть: плата совместимая с Arduino Uno, датчик DHT-11, три провода, Atmel Studio и машинные коды.
Для начало подготовим нужное оборудование.
Писать код будем в Atmel Studio 7 — бесплатно скачивается с сайта производителя микроконтроллера — Atmel.
Весь код запускался на клоне Arduino Uno — у меня это DFRduino Uno от DFRobot, на контроллере ATmega328p работающем на частоте 16 MHz — отличная надежная плата. Каких-либо отличий от стандартного Uno в процессе эксплуатации я не заметил. Похожая чорная плата от DFBobot, только “Mega” отлетала у меня 2 года в качестве управляющего контроллера квадрокоптера — куда ее только не заносило — проблем не было.
Для просмотра сигналов длительностью в микросекунды (а это на минутку 1 миллионная доля секунды), я использовал штуку, которая называется “логический анализатор”. Конкретно, я использовал клон восьмиканального USBEE AX Pro. Как смотреть для отладки такие быстрые процессы без осциллографа или логического анализатора — на самом деле даже не знаю, ничего посоветовать не могу.
Прежде всего я подключил свой клон Uno — как я говорил у меня это DFRduino Uno к Atmel Studio 7 и решил попробовать помигать светодиодиком на ассемблере. Как подключить описанно много где, один из примеров по ссылке в конце. Код пишется прямо в студии, прошивать плату можно через USB порт используя привычные возможности загрузчика Arduino -через AVRDude. Можно шить и через внешний программатор, я пробовал на китайском USBASP, по факту у меня оба способа работали. В обоих случаях надо только правильно настроить прошивальщик AVRDude, пример моих настроек на картинке
Полная строка аргументов:
-C “C:\avrdude\avrdude.conf” -p atmega328p -c arduino -P COM7 115200 -U flash:w:”$(ProjectDir)Debug\$(TargetName).hex:i
В итоге, для простоты я остановился на прошивке через USB порт — это стандартный способ для Arduio. На моей UNO стоит чип ATmega 328P, его и надо указать при создании проекта. Нужно также выбрать порт к которому подключаем Arduino — на моем компьютере это был COM7.
Для того, чтобы просто помигать светодиодом никаких дополнительных подключений не нужно, будем использовать светодиод, размещенный на плате и подключенный к порту Arduino D13 — напомню, что это 5-ая ножка порта «PORTB» контроллера.
Подключаем плату через USB кабель к компьютеру, пишем код в студии, прошиваем прямо из студии. Основная проблема здесь собственно увидеть это мигание, поскольку контроллер фигачит на частоте 16 MHz и, если включать и выключать светодиод такой же частотой мы увидим тускло горящий светодиод и собственно все.
Для того чтобы увидеть, когда он светится и когда он потушен, мы зажжем светодиод и займем процессор какой-либо бесполезной работой на примерно 1 секунду. Саму задержку можно рассчитать вручную зная частоту — одна команда выполняется за 1 такт или используя специальный калькулятор по ссылки внизу. После установки задержки, код выполняющий примерно то же что делает классический «Blink» Arduino может выглядеть примерно так:
cli sbi DDRB, 5 ; PORT B, Pin 5 - на выход sbi PORTB, 5 ; выставили на Pin 5 лог единицу loop: ; delay 1000 ms ldi r18, 82 ldi r19, 43 ldi r20, 0 L1: dec r20 brne L1 dec r19 brne L1 dec r18 brne L1 nop in R16, PORTB ; переключили XOR 5-ый бит в порту ldi R17, 0b00100000 EOR R16, R17 out PORTB, R16 rjmp loop
Но на самом деле так писать не очень хорошо, поскольку мы полностью похерили такие важные штуки как стек и вектор прерываний (о них — позже).
Ок, светодиодиком помигали, теперь для того чтобы практика работа с GPIO была более или менее осмысленной прочитаем значения с датчика DHT11 и сделаем это также целиком на ассемблере.
Для того чтобы прочитать данные из датчика нужно в правильной последовательность выставлять на рабочей линии датчика сигналы высокого и низкого уровня — собственно это и называется дергать ногой микроконтроллера. С одной стороны, ничего сложного, с другой стороны все какая-то осмысленная деятельность — меряем температуру и влажность — можно сказать сделали первый шаг к построению какой ни будь «Погодной станции» в будущем.
Забегая на один шаг вперед, хорошо бы понять, а что собственно с прочитанными данными будем делать? Ну хорошо прочитали мы значение датчика и установили значение переменной в памяти контроллера в 23 градуса по Цельсию, соответственно. Как посмотреть на эти цифры? Решение есть! Полученные данные я буду смотреть на большом компьютере выводя их через USART контроллера через виртуальный COM порт по USB кабелю прямо в терминальную программу типа PuTTY. Для того чтобы компьютер смог прочитать наши данные будем использовать преобразователь USB-TTL — такая штука которая и организует виртуальный COM порт в Windows.
Сама схема подключения может выглядеть примерно так:
Сигнальный вывод датчика подключен к ноге 2 (PIN2) порта PORTD контролера или (что то же самое) к выводу D2 Arduino. Он же через резистор 4.7 kOm “подтянут” на “плюс” питания. Плюс и минус датчика подключены — к соответствующим проводам питания. USB-TTL переходник подключен к выходу Tx USART порта Arduino, что значит PIN1 порта PORTD контроллера.
В собранном виде на breadboard:
Разбираемся с датчиком и смотрим datasheet. Сам по себе датчик несложный, и использует всего один сигнальный провод, который надо подтянуть через резистор к +5V — это будет базовый «высокий» уровень на линии. Если линия свободна — т.е. ни контроллер, ни датчик ничего не передают, на линии как раз и будет базовый «высокий» уровень. Когда датчик или контроллер что-то передают, то они занимают линию — устанавливают на линии «низкий» уровень на какое-то время. Всего датчик передает 5 байт. Байты датчик передает по очереди, сначала показатели влажности, потом температуры, завершает все контрольной суммой, это выглядит как “HHTTXX”, в общем смотрим datasheet. Пять байт — это 40 бит и каждый бит при передаче кодируется специальным образом.
Для упрощения, будет считать, что «высокий» уровень на линии — это «единица», а «низкий» соответственно «ноль». Согласно datasheet для начала работы с датчиком надо положить контроллером сигнальную линию на землю, т.е. получить «ноль» на линии и сделать это на период не менее чем 20 милсек (миллисекунд), а потом резко отпустить линию. В ответ — датчик должен выдать на сигнальную линию свою посылку, из сигналов высокого и низкого уровня разной длительности, которые кодируют нужные нам 40 бит. И, согласно datasheet, если мы удачно прочитаем эту посылку контроллером, то мы сразу поймем что: а) датчик собственно ответил, б) передал данные по влажности и температуре, с) передал контрольную сумму. В конце передачи датчик отпускает линию. Ну и в datasheet написано, что датчик можно опрашивать не чаще чем раз в секунду.
Итак, что должен сделать микроконтроллер, согласно datasheet, чтобы датчик ему ответил — нужно прижать линию на 20 миллисекунд, отпустить и быстро смотреть, что на линии:
Датчик должен ответить — положить линию в ноль на 80 микросекунд (мксек), потом отпустить на те же 80 мксек — это можно считать подтверждением того, что датчик на линии живой и откликается:
После этого, сразу же, по падению с высокого уровня на нижний датчик начинает передавать 40 отдельных бит. Каждый бит кодируются специальной посылкой, которая состоит из двух интервалов. Сначала датчик занимает линию (кладет ее в ноль) на определенное время — своего рода первый «полубит». Потом датчик отпускает линию (линия подтягивается к единице) тоже на определенное время — это типа второй «полубит». Длительность этих интервалов — «полубитов» в микросекундах кодирует что собственно пытается передать датчик: бит “ноль” или бит “единица”.
Рассмотрим описание битовой посылки: первый «полубит» всегда низкого уровня и фиксированной длительности — около 50 мксек. Длительность второго «полубита» определят, что датчик собственно передает.
Для передачи нуля используется сигнал высокого уровня длительностью 26–28 мксек:
Для передачи единицы, длительность сигнала высокого увеличивается до 70 микросекунд:
Мы не будет точно высчитывать длительность каждого интервала, нам вполне достаточно понимания, что если длительность второго «полубита» меньше чем первого — то закодирован ноль, если длительность второго «полубита» больше — то закодирована единица. Всего у нас 40 бит, каждый бит кодируется двумя импульсами, всего нам надо значит прочитать 80 интервалов. После того как прочитали 80 интервалов будем сравнить их попарно, первый “полубит” со вторым.
Вроде все просто, что же требуется от микроконтроллера для того чтобы прочитать данные с датчика? Получается нужно значит дернуть ногой в ноль, а потом просто считать всю длинную посылку с датчика на той же ноге. По ходу, будем разбирать посылку на «полу-биты», определяя где передается бит ноль, где единица. Потом соберем получившиеся биты, в байты, которые и будут ожидаемыми данными о влажности и температуре.
Ок, мы начали писать код и для начала попробуем проверить, а работает ли вообще датчик, для этого мы просто положим линию на 20 милсек и посмотрим на линии, что из этого получится логическим анализатором.
Определения:
========== DEFINES ======================================= ; определения для порта, к которому подключем DHT11 .EQU DHT_Port=PORTD .EQU DHT_InPort=PIND .EQU DHT_Pin=PORTD2 .EQU DHT_Direction=DDRD .EQU DHT_Direction_Pin=DDD2 .DEF Tmp1=R16 .DEF USART_ByteR=R17 ; переменная для отправки байта через USART .DEF Tmp2=R18 .DEF USART_BytesN=R19 ; переменная - сколько байт отправить в USART .DEF Tmp3=R20 .DEF Cycle_Count=R21 ; счетчик циклов в Expect_X .DEF ERR_CODE=R22 ; возврат ошибок из подпрограмм .DEF N_Cycles=R23 ; счетчик в READ_CYCLES .DEF ACCUM=R24 .DEF Tmp4=R25
Как я уже писал сам датчик подключен на 2 ногу порта D. В Arduino Uno это цифровой выход D2 (смотрим для проверки Arduino Pinout).
Все делаем тупо: инициализировали порт на выход, выставили ноль, подождали 20 миллисекунд, освободили линию, переключили ногу в режим чтения и ждем появление сигналов на ноге.
;============ DHD11 INIT ======================================= ; после инициализации сразу !!!! надо считать ответ контроллера и собственно данные DHT_INIT: CLI ; еще раз, на всякий случай - критичная ко времени секция ; сохранили X для использования в READ_CYCLES - там нет времени инициализировать LDI XH, High(CYCLES) ; загрузили старшйи байт адреса Cycles LDI XL, Low (CYCLES) ; загрузили младший байт адреса Cycles LDI Tmp1, (1<<DHT_Direction_Pin) OUT DHT_Direction, Tmp1 ; порт D, Пин 2 на выход LDI Tmp1, (0<<DHT_Pin) OUT DHT_Port, Tmp1 ; выставили 0 RCALL DELAY_20MS ; ждем 20 миллисекунд LDI Tmp1, (1<<DHT_Pin) ; освободили линию - выставили 1 OUT DHT_Port, Tmp1 RCALL DELAY_10US ; ждем 10 микросекунд LDI Tmp1, (0<<DHT_Direction_Pin) ; порт D, Pin 2 на вход OUT DHT_Direction, Tmp1 LDI Tmp1,(1<<DHT_Pin) ; подтянули pull-up вход на вместе с внешним резистором на линии OUT DHT_Port, Tmp1 ; ждем ответа от сенсора - он должен положить линию в ноль на 80 us и отпустить на 80 us
Смотрим анализатором — а ответил ли датчик?
Да, ответ есть — вот те сигналы после нашего первого импульса в 20 милсек — это и есть ответ датчика. Для просмотра посылки я использовал китайский клон USBEE AX Pro который подключен к сигнальному проводу датчика.
Растянем масштаб так чтобы увидеть окончание нашего импульса в 20 милсек и лучше увидеть начало посылки от датчика — смотрим все как в datasheet — сначала датчик выставил низкий/высокий уровень по 80 мксек, потом начал передавать биты — а данном случае во втором «полубите» передается «0»
Значит датчик работает и данные нам прислал, теперь надо эти данные правильно прочитать. Поскольку задача у нас учебная, то и решать ее будем тупо в лоб. В момент ответа датчика, т.е. в момент перехода с высокого уровня в низкий, мы запустим цикл с счетчиком числа повторов нашего цикла. Внутри цикла, будем постоянно следить за уровнем сигнала на ноге. Итого, в цикле будем ждать, когда сигнал на ноге перейдет обратно на высокий уровень — тем самым определив длительность сигнала первого «полубита». Наш микроконтроллер работает на частоте 16 MHz и за период например в 50 микросекунд контроллер успеет выполнить около 800 инструкций. Когда на линии появится высокий уровень — то мы из цикла аккуратно выходим, а число повторов цикла, которые мы отсчитали с использованием счетчика — запоминаем в переменную.
После перехода сигнальной линии уже на высокий уровень мы делаем такую же операцию– считаем циклы, до момента когда датчик начнет передавать следующий бит и положит линию в низкий уровень. К счастью, нам не надо знать точный временной интервал наших импульсов, нам достаточно понимать, что один интервал больше другого. Понятно, что если датчик передает бит «ноль» то длительность второго «полубита» и соответственно число циклов, которые мы отсчитали будет меньше чем длительность первого «полубита». Если же датчик передал бит «единица», то число циклов которые мы насчитаем во время второго полубита будет больше чем в первым.
И для того что бы мы не висели вечно, если вдруг датчик не ответил или засбоил, сам цикл мы будем запускать на какой-то временной период, но который гарантированно больше самой длинной посылки, чтоб если датчик не ответил, то мы смогли выйти по тайм-ауту.
В данном случае показан пример для ситуации, когда у нас на линии был ноль, и мы считаем сколько раз мы в цикле мы считали состояние ноги контроллера, пока датчик не переключил линию в единицу.
;============= EXPECT 1 ========================================= ; крутимся в цикле ждем нужного состояния на пине ; когда появилось - выходим ; сообщаем сколько циклов ждали ; или сообщение об ошибке тайм оута если не дождались EXPECT_1: LDI Cycle_Count, 0 ; загрузили счетчик циклов LDI ERR_CODE, 2 ; Ошибка 2 - выход по тайм Out ldi Tmp1, 2 ; Загрузили ldi Tmp2, 169 ; задержку 80 us EXP1L1: INC Cycle_Count ; увеличили счетчик циклов IN Tmp3, DHT_InPort ; читаем порт SBRC Tmp3, DHT_Pin ; Если 1 RJMP EXIT_EXPECT_1 ; То выходим dec Tmp2 ; если нет то крутимся в задержке brne EXP1L1 dec Tmp1 brne EXP1L1 NOP ; Здесь выход по тайм out RET EXIT_EXPECT_1: LDI ERR_CODE, 1 ; ошибка 1, все нормально, в Cycle_Count счетчик циклов RET
Аналогичная подпрограмма используется для того, чтобы посчитать сколько циклов у нас должно прокрутиться, пока датчик из состояния ноль на линии переложил линию в состояние единицы.
Для расчета временных задержек мы будет использовать тот же подход, который мы использовали при мигании светодиодом — подберем параметры пустого цикла для формирования нужной паузы. Я использовал специальный калькулятор. При желании можно посчитать число рабочих инструкций и вручную.
Памяти в нашем контроллере довольно много — аж 2 (Два) килобайта, так что мы не будем жлобствовать с памятью, и тупо сохраним данные счетчиков относительно наших 80 ( 40 бит, 2 интервала на бит) интервалов в память.
Объявим переменную
CYCLES: .byte 80 ; буфер для хранения числа циклов
И сохраним все считанные циклы в память.
;============== READ CYCLES ==================================== ; читаем биты контроллера и сохраняем в Cycles READ_CYCLES: LDI N_Cycles, 80 ; читаем 80 циклов READ: NOP RCALL EXPECT_1 ; Открутился 0 ST X+, Cycles_Counter ; Сохранили число циклов RCALL EXPECT_0 ST X+, Cycles_Counter ; Сохранили число циклов DEC N_Cycles ; уменьшили счетчик BRNE READ RET ; все циклы считали
Теперь, для отладки, попробуем посмотреть насколько удачно посчиталось длительность интервалов и понять действительно ли мы считали данные из датчика. Понятно, что число отсчитанных циклов первого «полубита» должно быть примерно одинаково у всех битовых посылок, а вот число циклов при отсчете второго «полубита» будет или существенно меньше, или наоборот существенно больше.
Для того чтобы передавать данные в большой компьютер будем использовать USART контроллера, который через USB кабель будет передавать данные в программу — терминал, например PuTTY. Передаем опять же тупо в лоб — засовываем байт в нужный регистр управления USART-а и ждем, когда он передастся. Для удобства я также использовал пару подпрограмм, типа — передать несколько байт, начиная с адреса в Y, ну и перевести каретку в терминале для красоты.
;============ SEND 1 BYTE VIA USART ===================== SEND_BYTE: NOP SEND_BYTE_L1: LDS Tmp1, UCSR0A SBRS Tmp1, UDRE0 ; если регистр данных пустой RJMP SEND_BYTE_L1 STS UDR0, USART_ByteR ; то шлем байт из R17 NOP RET ;============ SEND CRLF VIA USART =============================== SEND_CRLF: LDI USART_ByteR, $0D RCALL SEND_BYTE LDI USART_ByteR, $0A RCALL SEND_BYTE RET ;============ SEND N BYTES VIA USART ============================ ; Y - что слать, USART_BytesN - сколько байт SEND_BYTES: NOP SBS_L1: LD USART_ByteR, Y+ RCALL SEND_BYTE DEC USART_BytesN BRNE SBS_L1 RET
Отправив в терминал число отсчётов для 80 интервалов, можно попробовать собрать собственно значащие биты. Делать будем как написано в учебнике, т.е. в datasheet — попарно сравним число циклов первого «полубита» с числом циклов второго. Если вторые пол-бита короче — значит это закодировать ноль, если длиннее — то единица. После сравнения биты накапливаем в аккумуляторе и сохраняем в память по-байтово начиная с адреса BITS.
;============= GET BITS =============================================== ; Из Cycles делаем байты в BITS GET_BITS: LDI Tmp1, 5 ; для пяти байт - готовим счетчики LDI Tmp2, 8 ; для каждого бита LDI ZH, High(CYCLES) ; загрузили старшйи байт адреса Cycles LDI ZL, Low (CYCLES) ; загрузили младший байт адреса Cycles LDI YH, High(BITS) ; загрузили старший байт адреса BITS LDI YL, Low (BITS) ; загрузили младший байт адреса BITS ACC: LDI ACCUM, 0 ; акамулятор инициализировали LDI Tmp2, 8 ; для каждого бита TO_ACC: LSL ACCUM ; сдвинули влево LD Tmp3, Z+ ; считали данные [i] LD Tmp4, Z+ ; о циклах и [i+1] CP Tmp3, Tmp4 ; сравнить первые пол бита с второй половину бита если положительно - то BITS=0, если отрицительно то BITS=1 BRPL J_SHIFT ; если положительно (0) то просто сдвиг ORI ACCUM, 1 ; если отрицательно (1) то добавили 1 J_SHIFT: DEC Tmp2 ; повторить для 8 бит BRNE TO_ACC ST Y+, ACCUM ; сохранили акамулятор DEC Tmp1 ; для пяти байт BRNE ACC RET
Итак, здесь мы собрали в памяти начиная с метки BITS те пять байт, которые передал контроллер. Но работать с ними в таком формате не очень неудобно, поскольку в памяти это выглядит примерно, как:
34002100ХХ, где 34 — это влажность целая часть, 00 — данные после запятой влажности, 21 — температура, 00 — опять данные после запятой температуры, ХХ — контрольная сумма. А нам надо бы вывести в терминал красиво типа «Temperature = 21.00». Так что для удобства, растащим данные по отдельным переменным.
Определения
H10: .byte 1 ; чиcло - целая часть влажность H01: .byte 1 ; число - дробная часть влажность T10: .byte 1 ; число - целая часть температура в C T01: .byte 1 ; число - дробная часть температура
И сохраняем байты из BITS в нужные переменные
;============ GET HnT DATA ========================================= ; из BITS вытаскиваем цифры H10... ; !!! чуть хакнули, потому что H10 и дальше... лежат последовательно в памяти GET_HnT_DATA: NOP LDI ZH, HIGH(BITS) LDI ZL, LOW(BITS) LDI XH, HIGH(H10) LDI XL, LOW(H10) ; TODO - перевести на счетчик таки LD Tmp1, Z+ ; Считали ST X+, Tmp1 ; сохранили LD Tmp1, Z+ ; Считали ST X+, Tmp1 ; сохранили LD Tmp1, Z+ ; Считали ST X+, Tmp1 ; сохранили LD Tmp1, Z+ ; Считали ST X+, Tmp1 ; сохранили RET
После этого преобразуем цифры в коды ASCII, чтобы данные можно было нормально прочитать в терминале, добавляем названия данных, ну там «температура» из флеша и шлем в COM порт в терминал.
Для того, чтобы это измерять температуру регулярно добавляем вечный цикл с задержкой порядка 1200 миллисекунд, поскольку datasheet DHT11 говорит, что не рекомендуется опрашивать датчик чаще чем 1 раз в секунду.
Основной цикл после этого выглядит примерно так:
;============ MAIN ;!!! Главный вход RESET: NOP ; Internal Hardware Init CLI ; нам прерывания не нужны пока ; stack init LDI Tmp1, Low(RAMEND) OUT SPL, Tmp1 LDI Tmp1, High(RAMEND) OUT SPH, Tmp1 RCALL USART0_INIT ; Init data RCALL COPY_STRINGS ; скопировали данные в RAM RCALL TEST_DATA ; подготовили тестовые данные loop: NOP ; крутимся в вечном цикле .... ; External Hardware Init RCALL DHT_INIT ; получили здесь подтверждение контроллера и надо в темпе читать биты RCALL READ_CYCLES ; критичная ко времени секция завершилась... ;Тест - отправить Cycles в USART ;RCALL TEST_CYCLES ; получаем из посылки биты RCALL GET_BITS ;Тест - отправить BITS в USART ;RCALL TEST_BITS ; получаем из BITS цифровые данные RCALL GET_HnT_DATA ;Тест - отправить 4 байта начиная с H10 в USART ;RCALL TEST_H10_T01 ; подготовидли температуру и влажность в ASCII RCALL HnT_ASCII_DATA_EX ; Отправить готовую температуру (надпись и ASCII данные) в USART RCALL PRINT_TEMPER ; Отправить готовую влажность (надпись и ASCII данные) в USART RCALL PRINT_HUMID ; переведем строку дял красоты RCALL SEND_CRLF RCALL DELAY_1200MS ;повторяем каждые 1.2 секунды rjmp loop ; зациклились
Прошиваем, подключаем USB-TTL кабель (преобразователь)к компьютеру, запускаем терминал, выбираем правильный виртуальный COM порта и наслаждаемся нашим новым цифровым термометром. Для проверки можно погреть датчик в руке — у меня температура при этом растет, а влажность как ни странно уменьшается.
Ссылки по теме:
AVR Delay Calc
Как подключить Arduino для программирования в Atmel Studio 7
DHT11 Datasheet
ATmega DataSheet
Atmel AVR 8-bit Instruction Set
Atmel Studio
Код примера на github