понеділок, 13 квітня 2020 р.

ЗВ’ЯЗОК З RASPBERRY PI ЧЕРЕЗ UART

UART (Universal Asynchronous Receiver/Transmitter - універсальний асинхронний приймач/передавач) - протокол послідовного зв'язку, в якому дані передаються послідовно, тобто побітно. При такому зв'язку за один раз передається байт даних.
Існує велика кількість різноманітних протоколів зв'язку, призначених для використання з UART. Найбільш відомі:
MODBUS - сімейство протоколів типу «запит-відповідь», популярне в промисловій автоматиці. Орієнтовані на управління обладнанням за допомогою коротких команд.
AT-команди телефонних модемів. Набір текстових команд, що дозволяють управляти роботою модему при встановленні з'єднання.
PPP – протокол, який широко використовувався при підключеннях до інтернету через модем. Дозволяє виконувати аутентифікацію користувача у провайдера, шифрувати дані тощо.
IrDA - сімейство протоколів фізичного рівня для оптичного бездротового керування.
Протокол UART використовує певну структуру кадру для передачі байту даних. Структуа в асинхронному повідомленні наступна:
• Біт START - вказує, що послідовний зв'язок почався, і цей біт завжди має низький рівень сигналу.
• Пакет бітів даних - бітами даних можуть бути пакети від 5 до 9 біт. Як правило, використовується 8-бітний пакет даних, який завжди надсилається після START-біта.
• Біт STOP - це, зазвичай, один або два біти. Відправляється після пакетів бітів даних, щоб вказати кінець кадру. Біт STOP завжди має високий логічний рівень.
Кадр може також мати біт PARITY, який передається після STOP-біта.
UART зазвичай використовується в Raspberry Pi (RPi) як зручний спосіб керування через GPIO або для доступу до завантажувальних повідомлень ядра з послідовної консолі (включено за замовчуванням). Він також може бути використаний як спосіб для взаємодії з Arduino, завантаженого ATmega, ESP8266 та інших мікроконтролерів з RPi. Будьте обережні з рівнями логіки між пристроями, бо, наприклад, RPi має 3,3 В, а Arduino – 5 В. Підключивши їх разом ви можете їх пошкодити.
UART Raspberry Pi
Raspberry Pi має два вбудованих UART:
• PL011 UART
• mini UART
PL011 UART - це UART на базі ARM. Він має кращу пропускну здатність, ніж mini UART
Хоча RPi має два UART, але ми маємо лише одну пару виводів TXD і RXD для роботи.
UART PL011 є основним UART для моделей без функції Bluetooth і зв'язаний безпосередньо з консоллю Linux. Це означає, що через цей UART ви можете надсилати команди Linux з вашого ПК на RPi.
З іншого боку, mini UART є Linux консоллю UART для моделей з Bluetooth, такими як Raspberry Pi 3 і Raspberry Pi Zero W. Для цих моделей UART PL011 зв'язаний безпосередньо з модулем Bluetooth.
UART PL011 є більш надійним, ніж міні UART, оскільки останній має менші за обсягом FIFO, не може контролювати потік, а швидкість передачі даних залежить від тактової частоти GPU. Оскільки частота ядра графічного процесора змінюється, то змінюється і частота UART, що, в свою чергу, змінює швидкість передачі даних через UART. Це робить mini UART нестабільним, що може призвести до втрати даних або їх пошкодження. Щоб зробити mini UART стабільним, треба змінити основну частоту. Також mini UART не підтримує перевірку парності.
Для кращого та ефективного зв'язку рекомендується використовуйте PL011 UART замість mini UART.
Для використання послідовного зв'язку треба включити UART RPi. В іншому випадку ми не зможемо спілкуватися через послідовний порт, оскільки порти UART використовуються для виведення консолі Linux та модуля Bluetooth.
В RPi у вікні терміналу введіть наступну команду, щоб дозволити UART,
sudo raspi-config
Виберіть -> Interfacing Options:
Після вибору меню Interfacing, виберіть пареметр Serial, щоб дозволити UART:
Також дозволити використання UART можна через вкладку Interfaces меню параметрів у графічному інтерфейсі RPi.
Виводи Raspberry Pi 3 UART:
UART виводи мають номери: в режимі BCM 14, 15, а в режимі WiringPi 15, 16.
Якщо ви встановили WiringPi2-Python, то наступний приклад на python відкриває UART RPi на швидкості 9600 бот і надсилає 'hello world':

import wiringpi2 as wiringpi
wiringpi.wiringPiSetup()
serial = wiringpi.serialOpen('/dev/ttyAMA0',9600)
wiringpi.serialPuts(serial,'hello world!')


Зверніть увагу, що виводи RPi використовують рівні логіки 3,3 В, тому ви не можете підключити їх безпосередньо до пристроїв, які використовують 5 В: Arduino UNO або ПК.
Для доступу до mini UART в Raspberry Pi 3 присвоюється порт ttyS0. А для доступу до PL011 в Raspberry Pi 3 буде присвоєний порт ttyAMA0. В інших моделях RPi доступний тільки порт ttyAMA0.
Апаратний порт mini UART, тобто GPIO14 (TXD) та GPIO15 (RXD) відомий як serial0, тоді як інший порт UART, який за замовчуванням підключений до модуля Bluetooth, відомий як serial1. Ці імена створюються як псевдоніми для переносимості версій RPi. Псевдоніми створюються в Raspbian. Отже, ми можемо замінити ttyS0 або ttyAMA0 на serial0.
Коли ми використовуємо serial0 як UART-порт замість ttyS0 або ttyAMA0, то програма, написана для Raspberry Pi 3, також буде працювати на старих моделях RPi.
Для кращої продуктивності послідовного зв'язку на GPIO14 та GPIO15 необхідно використовувати порт ttyAMA0, який підключений до модуля Bluetooth. Для використання цього порту ми повинні обміняти порти UART, тобто отримати ttyAMA0 на GPIO14 та GPIO15, а ttyS0 (mini UART) в модулі Bluetooth.
Обмін послідовними портами можна здійснити за допомогою міні-UART (ttyS0) для модуля Bluetooth через оверлей пристрою, тобто pi3-miniuart-bt. Або це можна зробити, повністю відключивши Bluetooth через заборону пристрою, тобто pi3-disable-bt.
Щоб поміняти порт UART, відкрийте файл config.txt, як показано нижче.
sudo nano /boot/config.txt
а потім додайте нижче в кінці файлу рядок, як показано нижче.
dtoverlay = pi3-miniuart-bt
або
dtoverlay = pi3-disable-bt
Після додавання рядка збережіть зміни у файлі та перезавантажте систему.
Ми можемо перевірити нове відображення послідовних портів за допомогою
ls -l /dev
Карта UART для /dev/ttyS0 і /dev/ttyAMA0 показана нижче:
Підключення Raspberry Pi до ПК з використанням UART
Щоб підключити RPi до ПК через UART, необхідно мати USB Serial Cable, який підтримує 3,3В:
Як видно на зображенні вище, кабель має чотири дроти «мама», які можна підключити до RPi. Червоний дріт повинен бути підключений до +5 В, чорний - до GND, зелений - до TXD та білий - до RXD.
Даний кабель живиться від мікросхеми PL2303 і сумісний з Windows XP/Vista/7/8/10. Драйвер для кабелю можна завантажити зі сторінки Prolific’sdownloadpage.
Тепер можна використати термінал Putty, щоб спілкуватися з RPi через UART. За замовчуванням UART RPi використовує такі параметри: 115200 бод, 8 біт, без паритету, 1 стоп-біт і без контролю потоку.
Відкрийте Putty і виберіть перемикач "Serial". Потрібно також вказати COM-порт і швидкість, хоча Putty використовує ті ж самі параметри, що й вказані вище, за замовчуванням:
Якщо не знаєте, який номер COM-порту використати для кабелю USB, то необхідно:
1. Натиснути клавіші Windows+R, щоб відкрити діалогове вікно Run («Виконати») та набрати devmgmt.msc. Натисніть клавішу Enter, щоб відкрити диспетчер пристроїв в консолі ММС.
2. Клацнути стрілку на порти (COM & LPT), щоб виявити всі COM-порти на вашому ПК. Якщо ваш кабель USB-послідовний порт підключений, то він буде відображений у списку.
Коли все готово, натисніть кнопку Open на Putty, щоб використати консоль Linux через UART!
Тестування послідовного зв’язку між Raspberry Pi і ПК
Для перевірки послідовного з’єднання виконаємо підключення, які показані нижче:
Інтерфейс Raspberry Pi з ПК/ноутбуком для послідовного з’єднання
При цьому використана плата конвертора:
Відкрийте вікно терміналу на ПК/ноутбуці для приймання даних, які будуть передані з  RPi.
Тепер, введіть наступну команду для передавання даних з терміналу RPi:
echo “Hello” > /dev/ttyS0
Ця команда передає рядок “Hello” на вихід порта UART, тобто на вивід Tx і він повине бути відображений в додатку термінала ПК/ноутбука.
Нагадуємо, що за замовчуванням, до GPIO14 (TX) і GPIO15(RX) підключений mini UART.
Ще один приклад з’єднання через  UART RPi з використанням Python:
”””
З’єднання через  UART RPi з використанням Python
http://www.electronicwings.com
”””
import serial
from time import sleep

ser = serial.Serial ("/dev/ttyS0", 9600)    #відкривання порта на заданій
                          #швидкості в бодах
while True:
    received_data = ser.read()              #читання послідовного порта
    sleep(0.03)
    data_left = ser.inWaiting()             #перевірка отриманого байта
    received_data += ser.read(data_left)
    print (received_data)                   #виведення отриманих даних
    ser.write(received_data)                #послідовна передача даних
Використані функції:
serial.Serial(port,baudrate)
Це клас для послідовного порта, який використовується для відкривання порта. Створіть примірник для цього класу (тут використовується ім’я ser, але воно може бути будь-яким іншим).
Наприклад:
ser = serial.Serial(/dev/ttyS0, 9600)
Параметри:
            Port – ім’я порта, тобто. ttyUSB0, ttyS0, тощо або None
             Baudrate – Швидкість обміну в бодах, наприклад, 9600, 38400, тощо.

Наведені вище функції мають більше параметрів, але не всі вони використовуються тут. Щоб детальніше ознайомитися з ними звертайтеся за посиланням Python API for PySerial.

read(Size)
Ця функція використовується для читання даних на послідовному порту.
Параметр:
            Size – Кількість байт для читання. За замовчуванням Size рівне 1.
Return:
             Байти, прочитані з порта.

write(Data)
Ця функція використовується для відправлення/передавання даних через послідовний порт.
Параметр:
             Data – Дані для передавання
Return:
              Кількість байт для запису/передавання
Вихід з терміналу Raspberry Pi:
Виведення на термінал ПК/ноутбука:
На стороні ПК/ноутбука тут використане програмне забезпечення Realterm.
Використання UART для спілкування з іншими пристроями
Ви не можете використовувати /dev/serial0 UART для спілкування з іншими пристроями, якщо вони зв'язані з консоллю. На щастя, існує спосіб від'єднати цей порт від консолі Linux. Просто виконайте такі дії:
1. На терміналі запустіть sudo raspi-config
2. Виберіть 8 Advanced Options
3. Виберіть A8 Serial
4. Будь ласка, виберіть <No>, коли буде питання: “Would you like a login shell to be accessible over serial?”
5. Виберіть <Ok> та перезавантажте
Якщо ви правильно виконали наведені вище кроки, то тепер можете використовувати RPi UART для спілкування з мікроконтролерами, GPS-пристроями або іншими периферійними пристроями, що підтримують послідовнийінтерфейс!
Нижче наведений простий скрипт на python, який надсилає "Hello" до Arduino UNO через послідовний порт:
#!/usr/bin/env python
 
import time
import serial
 
ser = serial.Serial(
     port='/dev/serial0',
     baudrate = 9600,
     parity=serial.PARITY_NONE,
     stopbits=serial.STOPBITS_ONE,
     bytesize=serial.EIGHTBITS,
     timeout=1
)
 
while 1:
     ser.write('Hello\n')
     time.sleep(1)
Використана вище бібліотека Python для послідовного порта є однією з вбудованих бібліотек. Послідовний порт ініціалізується за допомогою рядків:
ser = serial.Serial(
     port='/dev/serial0',
     baudrate = 9600,
     parity=serial.PARITY_NONE,
     stopbits=serial.STOPBITS_ONE,
     bytesize=serial.EIGHTBITS,
     timeout=1
)
Тут вказані параметри послідовного порту RPi.
Щоб записати в послідовний порт просто необхідно використати функцію .write ():
ser.write ('Hello \ n')
В рядку доданий символ переходу на новий рядок (\n) в кінці "Hello".
Зверніть увагу, що для такого підключення треба матиперетворювач рівня логіки через різні рівні напруги!
Дотримуйтесь цієї електричної схеми:
Вам також потрібно завантажити ескіз SerialEvent до Arduino UNO. Перейдіть до File > Examples > 04.Communication > SerialEvent.
Щоб переглянути повідомлення з RPi, відкрийте монітор послідовного порта на IDE Arduino та встановіть швидкість передавання даних 9600.
Підключення модуля GPS до Raspberry Pi через UART
Існує два способи підключення UART/послідовних пристроїв до Raspberry Pi. Легкий спосіб, і важкий шлях.
Ми продемонструємо підключення обома способами на прикладі використання модуля GPS.
Простий шлях – використання зовнішнього конвертора USB-UART
Безсумнівно, найпростіший спосіб додати послідовний порт - це використати кабель з конвертором USB - UART. Кабель просто підключіть до порту USB, як ми робили вище для підключення RPi до ПК. На іншому кінці кабелю є проводи або роз’єм, які забезпечують живлення, землю, RX, TX та, можливо, інші контрольні функції чи додаткові пристрої. Замість кабелю можна використати плату-коніертор на мікросхемах CP2102 або CP2104.
Виконаємо підключення модуля GPS таким способом:
⦁    GPS Vin до USB 5В або 3В (червоний провід на кабелі USB)
⦁    GPS Ground до USB Ground (чорний провід)
⦁    GPS RX до USB TX (зелений провід)
⦁    GPS TX до USB RX (білий провід)
Після підключення адаптера USB вам потрібно з'ясувати, яке ім’я отримав послідовний порт. Знайти ім’я можна шляхом відключення-підключення до USB, а потім набравши команду:
dmesg | tail -10
(або просто dmesg) і шукати текст, схожий на наведений нижче:
Унизу ви побачите назву приєднаного пристрою, в даному випадку ім’я ttyUSB0, тобто наш пристрій послідовного порту доступний на /dev/ttyUSB0
Використання вбудованого UART
Якщо ви не хочете підключати зовнішнє устаткування до RPi, то можете використати вбудований UART на виводах RX/TX.
Але якщо ви це зробите, то втратите доступ до послідовну консолі, тому, якщо ви використовуєте кабель PiUART або консольний кабель чи HAT, який дозволяє підключатись безпосередньо до консолі, це більше не спрацює, і вам доведеться використовувати HDMI+клавіатуру або ssh-метод запуску команд!
Це не велика проблема, адже консоль послідовного входу більше не доступна за замовчуванням на Raspbian, але про це варто попередити!
Після перезавантаження ви можете використовувати вбудований UART за допомогою /dev/ttyS0
Під’єднайте GPS таким чином:

ВИКОРИСТАННЯ СЕНСОРІВ З ІНТЕРФЕЙСОМ

Інтерфейс I2C (Inter Integrated Circuit) створювався як простий інтерфейс з мінімально кількістю ліній зв'язку. Він використовує всього дві лінії для зв'язку ведучого пристрою з веденим: двонаправлену лінію даних SDA (Serial DAta) та лінію тактування SCL (Serial CLock) для синхронізації прийому і передачі даних.
Основний режим роботи — 100 кбіт/с; 10 кбіт/с в режимі роботи із зниженою швидкістю. Після введення стандарту 1992 року стало можливим підключення більшої кількості пристроїв на одну шину (за рахунок 10-бітної адресації), а також зросла швидкість обміну до 400 кбіт/с у швидкісному режимі (реалізовано в Raspberry Pi). Відповідно, доступна кількість вузлів зросла до 1008. Версія стандарту 2.0, випущена в 1998 році, представила високошвидкісний режим роботи зі швидкістю до 3,4 Мбіт/с зі зниженим енергоспоживанням.
I2C використовується в таких додатках як, читання RTC (годинник реального часу), доступ до зовнішньої пам'яті EEPROM, в модулях таких сенсорів, як гіроскоп, магнітометр тощо.
Зв'язок пристроїв через інтерфейс I2C на рівні електричних сигналів здійснюється з урахуванням наступних 4 правил:
1. ВИСОКИЙ рівень на лінії даних SDA або на лінії тактування SCL не може бути встановлений безпосередньо пристроєм I2C. Всі пристрої I2C повинні мати виходи з відкритим колектором (або відкритим стоком). ВИСОКИЙ рівень напруги на лініях формується зовнішніми підтягуються резисторами.
2. Інформація на лінії даних SDA зчитується лише при ВИСОКОМУ рівні на лінії тактування SCL.
3. Інформація на лінію даних SDA виставляється тільки при НИЗЬКОМУ рівні на лінії тактування SCL.
4. Якщо шина I2C в даний момент не використовується, то на лініях повинен бути встановлений ВИСОКИЙ рівень сигналу (логічна 1).
Основний формат кадру обміну через I2C складається з 11 біт. Спочатку посилається старт-біт, потім 8 біт даних, далі біт підтвердження прийому, потім стоп-біт. Форма подання старт і стоп-бітів порушує записане вище правило 3. Старт-біт визначається наявністю спадаючого фронту на лінії SDA при ВИСОКОМУ рівні сигналу на лінії SCL. Цю комбінацію сигналів прийнято також називати стартовим станом, або станом Start. Стоп-біт (або стан Stop) визначається наявністю наростаючого фронту на лінії SDA при ВИСОКОМУ рівні на лінії SCL. Стани Старт і Стоп генеруються ведучим пристроєм.
Стани Start і Stop на шині I2C
Після формування стартового біта ведучий пристрій виставляє на лінію даних SDA 8 біт даних, починаючи зі старшого біта байта. Кожен біт супроводжується імпульсом синхронізації SCL. Потім приймач генерує біт підтвердження прийому ACK, встановлюючи лінію SDA в НИЗЬКИЙ стан на інтервалі дев'ятого імпульсу на лінії SCL.
Якщо приймач не впізнав прийняті дані, то генерується біт «непідтвердження» прийому NACK, просто не переводячи лінію SDA в НИЗЬКИЙ стан. В цьому випадку передавач закінчує поточний сеанс передачі даних і генерує стоп-біт. Згідно алгоритму прикладної програми передавач пробує передати інформацію пізніше. На рис. нижче показані часові діаграми на лініях I2C, які супроводжують передачу та прийом байта 11010000 (передача успішна, біт підтвердження ACK сформований).

Кадри передачі та приймання даних через інтерфейс I2C
Тривалість фронтів при перемиканні в реальних системах не настільки мала, як показано на рис., оскільки реальні лінії мають розподілену ємність і до них підключені підтягуючі резистори. Чим більші значення ємності і опору підтягуючих резисторів, тим більша тривалості фронтів сигналів. Великий час наростання і спаду сигналу може привести до помилок при обміні даними між пристроями.
При проектуванні шини I2C необхідно враховувати кількість пристроїв, що підключаються, величини їх вхідної ємності і опорів підтягуючих резисторів. Деякі виробники напівпровідникових приладів пропонують спеціальні конвертори для збільшення кількості пристроїв, що підключаються до шини I2C.
Врахуйте, що максимальна сумарна ємність підключених до лінії I2C пристроїв не повинна перевищувати 400 пФ!
Протокол I2C передбачає можливість примусового зниження швидкості передачі даних веденим пристроєм в процесі самої передачі. Коли лінія SCL знаходиться в НИЗЬКОМУ стані, ведений пристрій може примусово продовжити цей стан на лінії, поки він не буде готовий прийняти наступний біт даних. Ця функція називається «розширенням тактових імпульсів».
При необхідності взаємодії декількох пристроїв по шині I2C у кожного підключеного до шини пристрою повинна бути своя адреса. Відповідно до специфікації протоколу I2C адреса може бути 7- або 10-бітовою.
Структура кадру обміну через I2C при передачі 7-бітної адреси: тарт-біт, 7 біт адреси, біт напрямку передачі для наступного кадру R/W, біт підтвердження ACK. Перші 9 біт, включаючи старт-біт, генеруються ведучим пристроєм, а біт підтвердження прийому - веденим пристроєм, чия адреса збігається з адресою, яку виставив на лінію ведучий:

Структура кадру обміну через I2C
Зазвичай 7-бітова адреса складається з двох частин: перші 4 біта визначають тип веденого пристрою, а останні 3 - номер пристрою зазначеного типу в системі. У табл. нижче наведені деякі типи пристроїв та їх спеціальні зарезервовані адреси при організації зв'язку через протокол I2C.
Процедура адресації відбувається наступним чином:
1. Ведучий пристрій генерує стан Старт.
2. Ведучий пристрій виставляє на лінію адресу веденого пристрою.
3. В залежності від значення біта R/W, ведучий пристрій посилає дані веденому пристрою (якщо R/W = 0) або зчитує дані, виставлені на лінію веденим пристроєм (R/W = 1).
4. Як тільки всі дані надіслані, ведучий пристрій генерує на лінії стан Stop.
У специфікації протоколу описаний ще один режим, який називається «Повторний старт». В цьому режимі ведучий пристрій встановлює ще раз стан Start і передає один байт адреси без генерації стану Stop. Це буває корисно для зміни напрямку передачі даних.
Використання інтерфейсу I2C на Raspberry Pi розглянемо на прикладі цифрового компасу HMC5883L.
Модуль магнітометра HMC5883L:
• Магнітометр HMC5883L використовується для вимірювання напрямку та величини магнітного поля Землі в дешевих цифрових компасах та магнітометрах.
• Вимірює значення магнітного поля Землі вздовж осей X, Y та Z від мілігауса до 8 гаус.
• Допомагає знайти напрямок руху пристрою.
• Для з’єднання використовує протокол I2C.
Магнітометр HMC5883L
Raspberry Pi має виводи інтерфейсу I2C, які показані нижче:

Щоб отримати доступ до шини I2C в Raspberry Pi, ми повинні виконати певні налаштування. Перш за все, треба дозволити інтерфейс I2C на Raspberry Pi. Це можна зробити через меню, або використати термінал, ввівши команду
sudo raspi-config
Вибираємо Interfacing Configurations, а потім I2C. Дозволяємо його і перезавантажуємо Raspberry Pi.
Після перезавантаження Raspberry Pi, перевіряємо, який режим використовує порт I2C, ввівши команду:
ls /dev/*i2c*
RPi повинен повернути назву порта i2c:

Вище показане використання інтерфейсу I2C в режимі i2c-1. Старі версії Raspberry Pi можуть повертати режим i2c-0.
Тепер підключимо магнітометр до порта I2C:

Магнітометр HMC5883L з Raspberry Pi 3
Далі, можемо протестувати/сканувати пристрої I2C, підключені до нашої плати Raspberry Pi, попередньо встановивши i2c-tools. Ми можемо отримати i2c-tools за допомогою apt-менеджера пакетів. Використайте таку команду в терміналі Raspberry Pi:
sudo apt install -y i2c-tools
Скануємо порт I2C за допомогою команди:
sudo i2cdetect -y 1
У відповідь ми повинні отримати адресу пристрою. Наприклад, ми підключили HMC5883L I2C до Raspberry Pi і спробували виявити цей пристрій, як показано нижче:

Команда i2cdetect сканує порт I2C, щоб отримати адресу пристрою, якщо він підключений.
Якщо пристрій не підключений до порту I2C, то повернеться поле з (- -).
Ми можемо отримати або встановити дані пристрою I2C за допомогою команд i2cget, i2cset, тощо
Наприклад,
sudo i2cget -y I2C_user_mode_Port address_of_device Register_address

sudo i2cget -y 1 0x68 0x01
і отримаємо дані, що містяться в реєстрі з адресою 0x01.
Ми можемо отримати доступ до шини I2C на Raspberry Pi, використовуючи SMBus. SMBus - це підмножина шини/інтерфейсу I2C. SMBus надає підтримку пристроям з інтерфейсом I2C. При написанні програми для доступу до пристрою на базі I2C використовуйте команди SMBus.
При розробці програм для зв'язку з Raspberry Pi через інтерфейс I2C на Python також використовуйте пакет бібліотеки SMBus, який надає широку підтримку доступу до пристроїв I2C. Отже, ми повинні додати підтримку SMBus для Python за допомогою пакетного менеджера apt:
sudo apt install python-smbus
Програмування
• По-перше, ми повинні встановити реєстр конфігурації A для середнього значення з 8 вимірювань з швидкістю виведення даних за замовчуванням 15 Гц.
• Налаштувати Gain, використовуючи регістр конфігурації B, тут вибрано 0xA0. (можемо вибрати будь-який інший бажаний)
.• Вибираємо в регістрі режиму режим безперервного вимірювання. Отже, значення регістра режиму буде рівне 0x00.
Після ініціалізації прочитаємо рядки значень регістрів X, Y та Z-осей.
Обчислюємо значення напрямку за допомогою такої формули
Зверніть увагу, що необхідно врахувати магнітне відхилення для даного географічного місця. Відхилення можна знайти, скориставшись ресурсом http://magnetic-declination.com. Запустивши сценарій на сайті, отримаємо для м.Київ:

Програма на Python

“””
    Знаходження напрямку з інтерфейсом HMC5883L за допомогою Raspberry Pi і Python
    http://www.electronicwings.com
”””
import smbus         #імпорт модуля SMBus інтерфейсу I2C
from time import sleep  #імпорт sleep
import math

#деякі регістри та їх адреси
Register_A     = 0              #Адреса регістра конфігурації A
Register_B     = 0x01           #Адреса регістра конфігурації B
Register_mode  = 0x02           #Адреса регістра режиму

X_axis_H    = 0x03              #Адреса регістра старшого байта даних X-осі
Z_axis_H    = 0x05              #Адреса регістра старшого байта даних Z-осі
Y_axis_H    = 0x07              #Адреса регістра старшого байта даних Y-осі
declination = 0.135             #кут відхилення для даного місця в радіанах
pi          = 3.14159265359     #значення pi


def Magnetometer_Init():
        #Запис в регістр конфігурації A
        bus.write_byte_data(Device_Address, Register_A, 0x70)

        # Запис в регістр конфігурації B для gain
        bus.write_byte_data(Device_Address, Register_B, 0xa0)

        #Запис в регістр режиму для вибору режиму
        bus.write_byte_data(Device_Address, Register_mode, 0)
    

def read_raw_data(addr):
    
        #Читання рядка 16-бітового значення
        high = bus.read_byte_data(Device_Address, addr)
        low = bus.read_byte_data(Device_Address, addr+1)

        #об’єднання старшого і молодшого байтів
        value = ((high << 8) | low)

        #отримання знаку значення з модуля
        if(value > 32768):
            value = value - 65536
        return value


bus = smbus.SMBus(1)     # або bus = smbus.SMBus(0) для старих версій плати
Device_Address = 0x68  # адреса магнітометра HMC5883L

Magnetometer_Init()    # ініціалізація магнітометра HMC5883L

print (" Reading Heading Angle")

while True:
    
    #Читання рядка значення акселерометра
        x = read_raw_data(X_axis_H)
        z = read_raw_data(Z_axis_H)
        y = read_raw_data(Y_axis_H)

        heading = math.atan2(y, x) + declination
        
        #Через відхилення перевіряємо чи не більше >360 градусів
        if(heading > 2*pi):
                heading = heading - 2*pi

        #перевірка знаку
        if(heading < 0):
                heading = heading + 2*pi

        #перетворення в градуси
        heading_angle = int(heading * 180/pi)

        print ("Heading Angle = %d°" %heading_angle)
        sleep(1)


Вирішення проблем
• Якщо результати команди i2cdetect видають помилку, то або не встановлено i2c-tools, або вам потрібно використати режим 0, а не 1
• Якщо пристрій не виявлений і ви не бачите адреси, то або ви неправильно підключили пристрій, або не включений інтерфейс i2c
• Двічі перевірте з’єднання і перезавантажте RPi
У рідкісних випадках може бути несправний пристрій, але набагато більш ймовірно, що має місце одна з перерахованих вище причин.

ПІДКЛЮЧЕННЯ СЕНСОРІВ З ІНТЕРФЕЙСОМ

1-Wire - протокол передачі даних в обидві сторони по одній лінії. Даний протокол розроблений корпорацією Dallas Semiconductor (зараз Maxim Integrated) в далеких 90-х, але активно використовується і зараз.
На 1-Wire сьогодні працює більшість "пігулок" - домофонних чіпів (DS1990A), карток доступу, а також через 1-Wire спілкуються популярні сенсори температури (DS18S20 і DS18B20), транзисторні ключі (DS2405, DS2406), програмовані порти введення-виведення (DS2408), АЦП і ЦАП, годинник реального часу (DS2417) і багато іншого.
Режим зв'язку в цьому протоколі - асинхронний і напівдуплексний, а при надсиланні мультибайтних цілих передача йде від молодшого байта до старшого. При цьому у нас завжди є ведучий - один пристрій на шині, який відсилає команди, і ведені - пристрої, які ці команди приймають і відповідають на них, якщо необхідно; кожний з ведених пристроїв підключається безпосередньо до загальної шині.
Ще раз підкреслимо - на шині може бути лише один ведучий - інакше виникнуть конфлікти, коли обидва ведучих «тягнутимуть ковдру на себе».
Протокол 1-Wire хороший тим, що не складний в реалізації і вимагає для зв'язку всього два-три дроти (шина даних, земля і, при необхідності, живлення); однак при цьому він не позбавлений і недоліків - цей протокол досить чутливий до часу і до завад. Також 1-Wire не призначений для передачі великих обсягів інформації та для швидкісного обміну даними - максимальна швидкість 15,4 Кбіт/с.
Відстань передачі досягає 300 м, якщо дотримуватися певних умов:
  • - застосування кабеля типу "вита пара";
  • - використання спеціального драйвера мережі (активне підтягування з врахуванням струму в лінії);
  • - використання технології «спільна шина» з єдиним стовбуром (не вільна топологія);

Фізично для організації інтерфейсу необхідні як мінімум лінія для даних і "земля"; досить часто також для підключення пристроїв необхідна також лінія живлення, проте деякі ведені пристрої можуть живитися і паразитно - отримувати "підживлення" через шину даних. Згідно інструкції з використання, шина даних повинна бути підтягнута до живлення резистором 4.7 кОм, однак даний номінал використовується при відносно коротких лініях; якщо ж відстань між пристроями досить велика, то опір резистора можна зменшити.
Обмін інформацією ведеться так званими тимчасовими, або тайм-слотами (60 мкс): один тайм-слот служить для обміну одним бітом інформації. Дані передаються біт за бітом, починаючи з молодшого біта молодшого байта - це, до речі, досить часто призводить до помилок у новачків - здається, що потрібно передавати дані зліва направо, так, як вони зберігаються в пам'яті - але при передачі по 1-Wire, наприклад, двобайтового числа порядок передачі буде таким:
Маємо число 1023410, яке в двійковому вигляді виглядає так: 00100111 11111010.
Передача по 1-Wire буде виглядати так:
0 → 1 → 0 → 1 → 1 → 1 → 1 → 1 → 1 → 1 → 1 → 0 → 0 → 1 → 0 → 0
При обміні інформацією ведучий ініціює кожний зв'язок на бітному рівні. Це означає, що передача кожного біта, незалежно від напрямку (передача чи прийом), повинна бути ініційована ведучим. Шина даних за замовчуванням підтягується до "одиниці", тому для початку як прийому, так і для передачі ведучий опускає лінію на деякий час в "нуль".
Увага: ні ведучий, ні ведені не виставляють на шині "одиницю" - це може призвести до короткого замиканням: якщо один пристрій виставить на шині "1", а інший - "0"; тому як ведучий, так і ведений можуть використовувати тільки два стани: "на вихід в нуль" і "z-стан" (на вхід без підтягування). Підтягування до живлення здійснюється резистором.
Розглянемо 5 основних команд для зв'язку по шині 1-Wire: "Запис 1", "Запис 0", "Читання", "Скидання" і "Присутність".
На малюнках червоним виділено управління лінією від ведучого, синім - управління лінією від веденого, чорним - звільнена лінія (за допомогою підтягування шина автоматично переходить в "одиницю").
Сигнал "Запис 1". Ведучий встановлює низький рівень протягом 1 ... 15 мкс. Після цього, протягом решти тимчасового слота він звільняє шину
Сигнал "Запис 0". Ведучий формує низький рівень протягом не менше 60 мкс, але не довше 120 мкс:
Сигнал "Читання". Ведучий встановлює низький рівень протягом 1 ... 15 мкс. Після цього ведений, якщо хоче передати 0, утримує шину в низькому стані до 60 мкс; якщо ж ведений хоче передати 1, то він просто звільняє лінію. Ведучий зазвичай сканує стан шини після закінчення 15 мкс після встановлення низького рівня на шині:
Так, ведений утримує лінію до землі, якщо хоче передати "0", і просто відпускає лінію, якщо хоче передати "1".
Таким чином при читанні отримуємо наступні діаграми:
Сигнал "Читання при отриманні 1":
Сигнал "Читання при отриманні 0":
Основні проблеми, які виникають при реалізації читання-запису - це проблеми з часом, тобто "невитримування", або навпаки, "перевитримування" тимчасових затримок при читанні лінії. Виникають ці проблеми через те, що часто не роблять поправку на затримку виконання команд мов програмування високого рівня. Особливо це стосується різних "додаткових" функцій.
Сигнал "скидання/присутність". Тут тимчасові інтервали імпульсів відрізняються. Ведучий встановлює низький рівень протягом 8 тимчасових слотів (480 мкс), а потім звільняє шину. Даний тривалий період низького стану називається сигналом "скидання".
Якщо на шині присутній ведений, то він повинен протягом 60 мкс після звільнення вкдучим шини встановити низький рівень тривалістю не менше 60 мкс. Даний відгук носить назву "присутність". Якщо такий сигнал не виявляється, то ведучий повинен думати, що немає підключених пристроїв до шини і подальший зв'язок неможливий.
Дана послідовність сигналів завжди починає будь-який обмін інформацією між пристроями.
Крім цього, потрібно враховувати, що будь-який ведений пристрій після підключення живлення відразу ж видає сигнал присутності.
Сигнал "скидання" дозволяє ведучому достроково завершити обмін інформацією - наприклад, якщо сенсор температури передає нам всю свою пам'ять, а нам потрібні тільки перші два байта, які містять значення температури, то після отримання цих двох байт мікросхема просто може опустити лінію в нуль на потрібну тривалість часу - сенсор зрозуміє, що більше нічого пересилати не треба.
При реалізації зазвичай необхідно запрограмувати мікроконтролер чи мікрокомп’ютер як ведучий пристрій, тому мікрокомп’ютеру варто генерувати сигнали тривалості трохи більшої необхідного мінімуму, а відповіді від ведених пристроїв чекати за найгіршими прогнозами - тоді взаємодія по протоколу буде оптимальною.
При цьому ведучому треба не забувати періодично перевіряти стан лінії даних - те, що вона повертається в підтягнутий стан з плином часу - а то може виникнути ситуація, наприклад, що який-небудь ведений зламався і закорочує, наприклад, лінію в нуль – і, в принципі, протокол не перевіряє дану проблему сам, хоча помилка може і не виникнути.
Розглянемо "вищий" рівень протоколу 1-Wire - послідовність дій при взаємодії ведучого і веденого, а також основні команди на прикладі використання температурних сенсорів.
Використання температурних сенсорів з Raspberry Pi
Raspberry Pi не має виводів АЦП (аналого-цифрового перетворювача) в GPIO, і тому зможемо використати лише цифровий сенсор температури.
Сенсор, який найчастіше вибирають, це Dallas DS18B20 - сенсор температури з інтерфейсом 1-Wire (однопровідний). Він відносно дешевий, його легко знайти, простий у використанні і показує температуру з точністю до +/-0,5 градуса у всьому діапазоні від -10 до +85 градусів Цельсія.
Для того, щоб він взаємодіяв з Raspberry Pi, нам потрібний лише один резистор - на 4,7 К, який діє як «підтягуючий» резистор, - і підключити все, як показано нижче:
Спочатку не забудьте дозволити інтерфейс 1-Wire в меню Налаштування -> Інтерфейси, щоб Raspberry Pi зміг приймати дані від сенсора.
Далі, увійдіть на Raspberry Pi і в командному рядку виконайте такі команди:

sudo modprobe w1-gpio
sudo modprobe w1_therm


щоб завантажити модулі ядра однопровідних пристроїв зв'язку, необхідні для використання сенсора температури.
(Щоб уникнути необхідності ручного введення цих команд щоразу, коли повторно завантажуєте Pi, відредагуйте з використанням nano або подібного редактора файл "/etc/modules" додаванням рядків w1-gpio і w1_therm у кінець файлу.)
Тепер в командному рядку введіть:

ls -l /sys/bus/w1/devices/

щоб побачити список пристроїв, підключених в даний момент до вашого Raspberry Pi.
Ваш сенсор температури з'явиться з адресою у форматі 28-00000xxxxxx. Нижче можете побачити, що адреса нашого сенсора температури була 28-00000283c6cd. Кожен сенсор температури DS18B20 має унікальну жорстко задану адресу, так що ви при необхідності можете підключити кілька сенсорів температури і, як і раніше, читати їх окремо.
Знайдіть свій сенсор температури і введіть наступну команду в терміналі, щоб відкрити файл сенсора і переглянути показання температури:

cat /sys/bus/w1/devices/28-00000283c6cd/w1_slave

(переконавшись, звичайно, що підставили адресу свого власного сенсора температури)

Вище ми бачимо, що на виході цієї команди є два рядки даних. Наприкінці другого рядку після "t=" є числове значення. Це значення є помножена на 1000 температура сенсора в градусах Цельсія. Тому, в нашому прикладі, ми бачимо показання t=24812 і температура буде 24812/1000 = 24,812 градусів за Цельсієм.
Читати температуру за допомогою командного рядка, як тут, не дуже зручно. Загалом ми хочемо вимірювати температуру через регулярні проміжки часу і або відображати десь, або зберігати в файлі для подальшого аналізу. Для цього ми повинні написати сценарій. Наш простий сценарій на Python для вимірювання та відображення температури один раз в секунду може бути таким:
Цей сценарій один раз на секунду читає файл сенсора температури, отримує другий рядок, розбиває його на розділені пробілами елементи, отримує десятий з цих елементів (деномінованих '9', бо '0' є першим елементом), пропускає перші два символи ("t=") цього елемента і перетворює те, що залишається (24812 в нашому прикладі), з рядка в числове значення, яке потім ділиться на 1000, щоб показати нам температуру, яка виводиться на екран.
Скріншот вище показує запуск сценарію поки сенсор температури проходить нагрівання.

Сценарій Python для читання даних з сенсора
Створимо новий сценарій Python у вікні терміналу (наприклад, з nano temperature.py) або з IDLE (Interactive Development Environment).
Нашим першим кроком є імпорт необхідних модулів: os дозволяє нам включити драйвери 1-Wire та інтерфейс з нашим сенсором, а time дозволяє Raspberry Pi визначити час та використовувати часові періоди в нашому коді.
Введемо наступний код:

# Імпорт бібліотек
import os
import time

# Ініціалізація виводів GPIO
os.system('modprobe w1-gpio') # Вмикання модуля GPIO
os.system('modprobe w1-therm') # Вмикання модуля Temperature

# Отримання device file (w1_slave file), який зберігає дані температури
temp_sensor = ‘sys/bus/w1/devices/28-000005e2fdc3/w1_slave

# Функція, яка читає дані з сенсора
def temp_raw():
   f = open(temp_sensor, 'r') # Відкриття значення температури в device file
   lines = f.readlines() # Повернення тексту
   f.close()
   return lines

# Перетворення значення сенсора в температуру
def read_temp():
   lines = temp_raw() # Читання температури 'device file'

   # Якщо перший рядок не має 'YES', чекати 0.2 с
   # і потім прочитати device file знову.
   while lines[0].strip()[-3:] != 'YES':
      time.sleep(0.2)
   lines = temp_raw()

   # Знаходження позиції '=' в другому рядку
   # device file.
   temp_output = lines[1].find('t=')

   # Якщо '=' знайдено, то перетворення решти рядка після
   # '=' в градуси Цельсія, а потім в градуси Фаренгейта
   if temp_output != -1:
      temp_string = lines[1][temp_output +2:]
      temp_c = float(temp_string) / 1000.0
      temp_f = temp_c * 9.0 / 5.0 + 32.0
      return temp_c, temp_f

# Виведення температури, поки не зупинимо програму.
while True:
   print(read_temp())
   time.sleep(1)
Щоб запустити код, необхідно визвати його з правами Super User:
sudo python temperature.py

Швидке відображення температури в командному рядку – Bash
Замість того, щоб писати сценарій Python для читання температури з сенсора, можна написати один рядок команди, яка буде читати сенсора, витягувати температуру з частини повернутих даних і обробляти результат за допомогою Bash в командному рядку Raspberry Pi.
Є багато способів для досягнення цієї мети, але от один приклад з використанням sed і awk:

cat /sys/bus/w1/devices/28-00000283c6cd/w1_slave | sed -n 's/^.*\(t=[^ ]*\).*/\1/p' | sed 's/t=//' | awk '{x=$1}END{print(x/1000)}'

Символ труби "|" використовується для передачі виводу однієї команди до наступної команди. Цей скрипт спочатку читає температуру з сенсора, перш ніж повернути два рядки даних, остання частина другого рядка, яка є t=XXXXX, де XXXXX - температура в мілліградусах Цельсія. Потім ми використовуємо sed, щоб знайти «слово», яке починається з 't=' в даних, далі пересилаємо його до другої команди sed, яка видаляє 't='. Нарешті, чисельний результат пересилається до команди awk, яка ділить цей результат на 1000 і відображає температуру в градусах Цельсія.
Очевидно, що ви не хотіли б набирати цей довгий рядок щоразу, коли перевіряєте температуру свого сенсора, тому можете створити псевдонім:
alias checktemp="cat /sys/bus/w1/devi......x/1000)}"

Тепер при введенні команди checktemp в командному рядку, будуть запущені всі збережені команди.

Альтернативно, можете зберегти команди як сценарій оболонки. Для цього відкрийте текстовий редактор за допомогою команди:

sudo nano checktemp

який створить порожній файл з ім'ям checktemp. Введіть:

#!/bin/bash

в першому рядку, а потім введіть команди cat /sys/bus... і т.д. в другому рядку. Натисніть Ctrl-X, щоб вийти і зберегти файл. Щоб зробити даний файл виконуваним для можливості його запуску, введіть:

chmod +x checktemp

і, нарешті, перемістимо його в каталог /usr/bin, де зберігається більшість виконуваних файлів:

mv checktemp /usr/bin/

Тепер, коли набираєте checktemp в командному рядку, то буде запускатися ваш сценарій і буде відображатися прочитана з сенсора температура.

Підключення декількох сенсорів температури до Raspberry Pi
Тепер ми розглянемо, як можна під’єднати кілька сенсорів температури до Raspberry Pi, що особливо корисне для деяких додатків вимірювання різниці температур, де потрібні два або більше сенсорів температури.
Вище показано, як схематично підключити три температурних сенсори DS18B20 до GPIO виводів Raspberry Pi. Відзначимо, що хоча ми використовуємо декілька температурних сенсорів для читання, ми маємо три з'єднання з Raspberry Pi: 3,3 В і 0 В підключення живлення сенсорів, і один провід даних, який повертає прочитану температуру від всіх сенсорів.
Прочитати показання температури з декількох сенсорів через один провід можна тому, що кожен сенсор DS18B20 має унікальний серійний номер, закодований в нього при виготовленні, який Raspberry Pi може використати для його ідентифікації.
При використанні декількох сенсорів, перше, що треба зробити, це отримати серійний номер для кожного сенсора і фізично маркувати їх, щоб знати, де який сенсор, коли будете встановлювати їх у різних місцях всієї системи.
Дотримуйтесь інструкцій, наведених вище, про підключення одного сенсора, щоб встановити кожен з них на своєму Raspberry Pi і скористайтеся командою:

ls -l sys/bus/w1/devices

щоб знайти серійний номер для першого сенсора.
Потім додайте другий сенсор і визначте його, повторно перевіривши підключені пристрої та відзначте його серійний номер. Повторіть цей процес, поки не підключите і не визначите всі сенсори.
Щоб підтвердити, що все працює як треба, отримайте температуру з кожного сенсора один за одним за допомогою команди:

cat /sys/bus/w1/devices/28-00000xxxxxxx/w1_slave

... замінивши XXXXXXX правильним серійним номером для кожного сенсора.
Тепер ви готові використовувати сенсори температури у своєму проекті на Raspberry Pi. Подібним чином можна використовувати з Raspberry Pi й інші цифрові сенсори з інтерфейсом 1-Wire.

Використання WebIOPi для роботи з сенсорами
WebIOPi також може обробляти отримані дані з різних пристроїв, у тому числі з сенсорів. Ви можете використовувати цю функціональність, щоб перетворити свій RPi в веб-термометр, підключивши сенсор температури до нього і створивши простий додаток WebIOPi для читання даних сенсора. Ми використаємо сенсор температури DS18S20 і резистор 4.7K.
Почніть з підключенням обох компонентів, як було показано на схемі вище (вивід "землі" 1 - до виводу Ground, вивід даних 2 -.до виводу 7 GPIO, а вивід живлення 3 - до 3,3 В)
Після підключення DS18B20 подайте живлення на RPi, зайдіть в систему, далі введіть в терміналі:
sudo nano /boot/config.txt.
Додайте внизу текста, який відкрився, рядок:
dtoverlay=w1–gpio
Збережіть зміни, вийдіть з nano і перезавантажте RPi
sudo reboot
Далі, ви повинні включити сенсор в конфігурації WebIOPi. Щоб зробити це, запустіть команду:
sudo nano /etc/webiopi/config
Розкоментуйте рядок
#temp2 = DS18B20
(тобто, видаліть символ #) у розділі DEVICES. Потім перезавантажте WebIOPi допомогою команди:
sudo /etc/init.d/webiopi restart
Якщо ви вже завантажили в терміналі необхідні модулі ядра w1-gpio і w1-therm, як описано вище, і знайшли серійний номер сенсора температури, то можемо відкрити браузер.
Введіть в браузері адресу
http://raspberrypi:8000/app/devices-monitor
 і ви повинні побачити поточне показання температури. Звичайно, сторінка за замовчуванням для моніторингу сенсорів та пристроїв є недостатньою і не особливо функціональною, тому, можливо, захочете створити свій власний веб-додаток для читання і відображення даних сенсора. Але чудово, що вам не доведеться починати з нуля: На офіційному форумі WebIOPi, ви можете знайти розумний веб-додаток, який зчитує температуру і відображає її за допомогою віджета Google gauge як показано на рис. нижче:
Код, щоб вивчити і налаштувати показ температури з Google Gauge, такий:
<html>
         <head>
         <script type="text/javascript"
src="//www.google.com/jsapi"></script>
         <script type="text/javascript" src="/webiopi.js"></script>
         <script type="text/javascript">
         webiopi().ready(function() {
         tmp = new Temperature("temp2");{
         setInterval(updateUI,1000);
         }
                 function updateUI() {
                         tmp.getCelsius(temperatureCallback);
                 }
                 function temperatureCallback(tmp, data) {
                         gaugeData.setValue(0, 0, data);
                         gauge.draw(gaugeData, gaugeOptions);
                 }
         });
         </script>
         <script type="text/javascript">
         google.load('visualization', '1', {packages: ['gauge']});
         google.setOnLoadCallback(drawGauge);
         var gaugeOptions = {min: 0, max: 110, yellowFrom: 50, yellowTo: 70,
         redFrom: 70, redTo: 110, minorTicks: 5};
         var gauge;
         function drawGauge() {
                 gaugeData = new google.visualization.DataTable();
                 gaugeData.addColumn('number', 'Temp');
                 gaugeData.addRows(1);
                 gaugeData.setCell(0, 0, 0);
                 gauge = new google.visualization.Gauge(document.getElementById('gauge_div'));{
                 gauge.draw(gaugeData, gaugeOptions);
                 }
         }
         </script>
</head>
<body>
<div id="gauge_div" style="width:560px; height: 280px;"></div>
</body>
</html>
Нам потрібно переналаштувати WebIOPi, щоб він використовував каталог /home/pi/project/html, як свій кореневий каталог документів. Створіть відповідні каталоги і в каталозі html збережіть показаний вище код.
Тепер внесіть зміни у файл конфігурації:
sudo nano /etc/webiopi/config
Команда відкриє конфігураційний файл у текстовому редакторі nano. Додайте рядок doc-root = /home/pi/project/html в секції [HTTP]. Збережіть зміни і перезавантажте WebIOPi за допомогою:
sudo /etc/init.d/webiopi restart
В браузері за посиланням http://raspberrypi:8000 ви повинні побачити відображення температури з Google Gauge, звичайно, замінивши raspberrypi на ІР-адресу свого мікрокомп’ютера.