Подключение дисплея 2019 к ардуино по i2c: Подключение дисплея LCD 1602 к arduino по i2c / IIC с конвертером — Производство и поставка электростанций, Бензиновые и дизельные генераторы от 1 до 100 кВт. Мини ТЭЦ на базе двигателя Стирлинга.

Содержание

arduino 20×4 lcd i2c code

[adrotate banner =”7″]

Дисплей шестнадцать на два устройства, что означает, что он может отображать 16 столбцы по две строки символов. Буквы алфавитно-цифровые, но вы можете создавать собственные символы для основных графических гистограмм. Такого типа дисплей обычного типа с контроллером HD44780., а также рюкзак I в квадрате C., что позволяет легко подключиться к uno you. Итак, первое, что нам нужно сделать, это подключить ЖК-дисплей к разъему uno.. Для этого я воспользуюсь соединительными проводами., контакты на ЖК-дисплее помечены как заземление VCC s da и s CL заземление. Подключаемся к земле. Пин на уно. Вывод VCC — это мощность на дисплее, и он работает от пяти вольт., так что мы можем подключить его к пятивольтовому выходу на uno. SD, штырь — это данные C в квадрате, и он подключен к штырю четверке на uno. Контакт SCL — это часы C в квадрате., и это связано с пятёркой на тех, кто знает. Этот метод подключения отлично подходит для подключения одного устройства I в квадрате C, если соединительные провода совершенно уверены, если мы сделаем соединительные провода длиннее или добавим несколько устройств., тогда нам нужно будет добавить подтягивания, резисторы к линиям SDA и Scl, Следующее, что нам нужно сделать, это установить библиотеку Arduino для ЖК-дисплея.

Я использовал один Франсиско Мал Партида, называется новым жидким кристаллом, и его можно загрузить с сайта bitbucket org. Я, поместите ссылку в описание, а также карточку, к которой вы можете получить доступ, щелкнув символ I в правом верхнем углу, угол экрана после того, как мы загрузили zip-файл библиотеки, затем запускаем программу выбора arduino ide, Sketch включает библиотеку и zip-файл, а затем выберите zip-файл, который мы загрузили. Как я намекал ранее, Я в квадрате c могу поддерживать несколько устройств. Каждое устройство представляет собой семибитный адрес для идентификации. Не всегда очевидно, какой адрес у устройства., но найти это, мы можем запустить сканер квадрата C, еще раз набросаю ссылку в описании и карточку, поэтому нам просто нужно скомпилировать и запустить скетч, откройте окно монитора, и он отобразит квадрат C-адреса ЖК-дисплея. Итак, теперь, когда мы знаем квадрат C-адреса ЖК-дисплея и установили библиотеку, мы можем попробовать простой набросок.. Это печатает привет, мир на ЖК-дисплее. Первая строка включает библиотеку проводов. Вторая строка включает жидкокристаллическую библиотеку C I в квадрате, которую мы установили ранее.. Библиотека проводов используется жидким кристаллом I в квадрате C, для обеспечения связи I в квадрате C с рюкзаком на ЖК-дисплее. Третья линия. Создает или создает объект, называемый ЖК-дисплеем, с параметрами ЖК-дисплея..

Первый параметр — это квадрат C-адреса, который мы нашли с помощью скетча сканера C I в квадрате, остальные параметры назначения контактов для ПК f8 5748 немного. Io expand чип на рюкзаке I в квадрате C разные рюкзаки имеют разные конфигурации. Так, если вы используете другой, тогда эти параметры, возможно, потребуется изменить. Begin инициализирует интерфейс для ЖК-дисплея и указывает экран, ширина и высота чистые, очищает ЖК-дисплей и позиции. Курсор в левом верхнем углу, угол и печать отпечатков на ЖК-дисплее. Итак, давайте скомпилируем это и посмотрим, что произойдет с вами.. Мы также можем попробовать пример, поставляемый с новой библиотекой жидких кристаллов, просто перейдите к примерам файлов., жидкость, кристалл и привет мир, Я возложил C. В таком случае. Нам просто нужно изменить параметры жидкого кристалла в квадрате C, так что я, просто собираюсь вставить их, теперь мы можем скомпилировать эскиз и загрузить его, и он создаст небольшую анимацию на ЖК-дисплее. Есть несколько хороших примеров, которые поставляются с исходной библиотекой жидких кристаллов.. Давайте посмотрим на пример прокрутки. В таком случае, нам нужно заменить жидкокристаллическую библиотеку, с библиотекой жидкого кристалла I в квадрате C, а затем заменить жидкий кристалл жидким кристаллом. Я скомпилировал C и загрузил скетч, и на этот раз мы получаем прокручивающийся привет мир. в заключение, если ЖК-дисплей не работает, проверьте, проводка убедитесь, что скетч сканера C в квадрате C может найти адрес устройства в квадрате C.

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

[adrotate banner =”1″]

[mam_video id = xVC0X_PE_XE]

[adrotate banner =”2″]

[mam_tag id = 3580]

[adrotate banner =”3″]

[adrotate banner =”4″]

[adrotate banner =”5″]

👋 Хотите, чтобы принести Тони Старк, как жест управления для ваших проектов? Узнайте, как с BLE поддержкой WiFi МКРА 1010 и Nano 33 BLE доски Sense, используя библиотеку ArduinoBLE.

Ардуин-йо-хо-хо! Ярмарочной любимый, пиратский корабль представляет собой интересный способ, чтобы исследовать колебания маятника. Сколько удовольствия, ты спрашиваешь? Доступ к нашей лаборатории физики Science Kit Предварительный просмотр и убедитесь сами: http://bit.ly/2oC6L0Q

🔬 Теперь, когда вы получили ваши ноги мокрые, погружение в комплект и наслаждаться все девять экспериментов. Сегодня ваша: http://bit.ly/2MnQ7fr

[adrotate banner =”6″]

Lcd 2004 подключение к ардуино по i2c

Опубликовано 04.04.2013 11:00:00

LCD I2C модуль позволить подключить символьный дисплей к плате Arduino всего по двум сигнальным проводам.

Используемые компоненты (купить в Китае):

• Управляющая плата

Arduino UNO 16U2, либо более дешевая Arduino UNO Ch440G,

Arduino Nano Ch440G, либо Arduino MEGA 16U2, либо более дешевая Arduino MEGA Ch440G,

Arduino PRO mini, либо Arduino Micro

• LCD I2C модуль

• Соединительные провода

Основные технические характеристики:

• Дисплей: Символьный 16х02 либо 20×04
• Подсветка: Синяя c белыми символами
• Контраст: Настраивается потенциометром
• Напряжение питания: 5В
• Интерфейс: I2C
• I2C адрес: 0x27
• Размеры: 82мм x 35мм x 18мм

Подключение к Arduino

Модуль оборудован четырех-пиновым разъемом стандарта 2.54мм

SCL: последовательная линия тактирования (Serial CLock)

SDA: последовательная линия данных (Serial DAta)

VCC: «+» питания

GND: «-» питания

Выводы отвечающие за интерфейс I2C на платах Arduino на базе различных контроллеров разнятся

LCD I2C модуль	На базе ATmega 328	Leonardo	MEGA, ADK, DUE
SCL	A5	D3	D21
SDA	A4	D2	D20
VCC	+5V	+5V	+5V
GND	GND	GND	GND

Для работы с данным модулем необходимо установить библиотеку LiquidCrystal_I2C1602V1

Скачиваем, распаковываем и закидываем в папку libraries в папке Arduino. В случае, если на момент добавления библиотеки, Arduino IDE была открытой, перезагружаем среду.

Переходим непосредственно к скетчу. В данном примере выведем стандартный «Hello, world!» и для адрес нашего сообщества.

пример программного кода:

Создание собственных символов

С выводом текста разобрались, буквы английского алфавита зашиты в память контроллера внутри дисплея и с ними проблем нет. А вот что делать если нужного символа в памяти контроллера нет?

Не беда, требуемый символ можно сделать вручную. Данный способ частично, ограничение в 7 символов, поможет решить проблему вывода.

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

В ниже приведенном примере нарисуем смайлик.

пример программного кода:

Программка для легкого создания символов

В комментариях участник сообщества скинул ссылку на генератор символов

генератор символов по примеру выше,

сделал потому что не слабо )
http://codepen.io/nardist01/pen/RPPvMg?editors=101

Статьи в подобной тематике:

Купить в России LCD I2C модуль

А как же комментарии?

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

Кто сказал, что символьные дисплеи для символов? Какие-то скучные чуваки. Если бы это было так, эти дисплеи не были бы настолько любимы и популярны в Arduino среде (купить можно тут https://alexgyver.ru/arduino_shop/). Подробного гайда лично от меня пока что нет, но суть такая: в этих дисплеях есть 8 ячеек для хранения “кастомных” символов, то есть символов, которые можно нарисовать самому, например при помощи различных онлайн сервисов типа такого http://maxpromer.github.io/LCD-Character-Creator/. Полученный массив байтов вставляется в скетч, передаётся в дисплей, и затем можно им пользоваться при помощи команды write(). Простой пример есть на офф сайте Ардуино https://www.arduino.cc/en/Reference/LiquidCrystalCreateChar. К слову эти ячейки в памяти занимают места с 0 по 7

Был у меня оч крутой проект, PCdisplay https://alexgyver.ru/pcdisplay/, в котором на дисплее 2004 отображалась в реальном времени информация о железе ПК: температуры и проценты загрузки, для красоты я выводил показатели не только числами, но и графически, в виде “полос загрузки” и графиков.

Проект получился очень классный, но вот я подумал, а почему бы не вынести построение графиков и полос загрузки удобными отдельными функциями? Ведь по-любому пригодятся кому-нибудь из вас, а достать код из PCdisplay новичку не под силу (к тому же он там чутка кривоват…). Так что представляю вашему вниманию GyverLCDbars – набор удобных инструментов для украшения ваших проектов графическими элементами: полосками загрузки и графиками. Актуальная версия всегда лежит у меня на GitHub https://github.com/AlexGyver/GyverLCDbars. ТЫКНИ для прямой загрузки архива.

В библиотеке вас ждёт 6 примеров: 4 типа полос загрузки и два примера с графиком.

Как этим пользоваться? Да очень просто. Одна функция для инициализации “кастомных” символов, вторая – для вывода нужного элемента с настройками его размера и позиции на дисплее!

Полоса загрузки: fillBar(столбец, строка, ширина, значение)

Столбец: отвечает за положение левой точки полосы, нумерация идёт слева направо с нуля
Строка: отвечает за положение левой точки полосы, нумерация идёт сверху вниз с нуля
Ширина: полная ширина полосы по горизонтали. Очевидно, что ширина + стартовая позиция по горизонтали (столбец) не должны превышать ширину дисплея в символах по горизонтали
Значение: число от 0 до 100 – процент заполнения полосы. Любая ваша величина приводится к диапазону 0-100 при помощи ардуиновской функции map
Особенность: если вы используете свои кастомные символы, то перед выводом полосок нужно обязательно вызвать initBar() для загрузки в память дисплея символов полосы! Полоски занимают разное количество мест в зависимости от типа, подробнее смотрите в самих примерах

График из массива: drawPlotArray(столбец, строка, ширина, высота, мин. значение, макс. значение, массив) – смотри пример!

График в реальном времени: drawPlot(столбец, строка, ширина, высота, мин. значение, макс. значение, величина)

Столбец: нумерация идёт слева направо с нуля. Начало координат графика – нижняя левая точка!
Строка: нумерация идёт сверху вниз с нуля. Начало координат графика – нижняя левая точка!
Ширина: ширина графика по горизонтали. Очевидно, что ширина + стартовая позиция по горизонтали (столбец) не должны превышать ширину дисплея в символах по горизонтали
Высота: высота графика по вертикали. Очевидно, что высота+ стартовая позиция по вертикали (строка) не должны превышать высоту дисплея в символах по вертикали. То есть для 2004 максимум высота 4, для 1602 максимум 2.
Мин. значение: минимальное значение для графика, ниже него строиться не будет (тип данных int -32,768 to 32,767)
Макс. значение: максимальное значение для графика, выше него строиться не будет (тип данных int -32,768 to 32,767)
Величина: значение, которое будет построено на графике с краю, предыдущие столбики автоматически сдвинутся в сторону при вызове функции drawPlot. Тип данных int -32,768 to 32,767
Также в примере есть готовый кусок кода для расчёта и вывода максимального и минимального значения на текущем графике!
Особенность: если вы используете свои кастомные символы, то перед выводом графика нужно обязательно вызвать initPlot() для загрузки в память дисплея символов графика! Они занимают все места, с 0 по 7!

Символьный дисплей “LCD2004” может выводить 20 символов в каждой из 4 строк, имеет голубую подсветку, которую можно отключить с помощью джампера (перемычки) на плате. Для подключения “LCD2004” к микроконтроллеру имеется интерфейс “I2C”.

Символьный дисплей – вид сзади

Подключение LCD2004 к Arduino через I2C:

GND – общий
VCC – ” +5 В”
SDA – последовательная линия данных – на Arduino Uno и Nano А4 (SDA), на Arduino Mega – 20 (SDA)
SCL – последовательная линия синхронизации – на Arduino Uno и Nano А5 (SCL), на Arduino Mega – 21 (SCL)

Схема подключения 2004-lcd к Arduino через I2C

Характеристики:

строк: 4
символов в строке: 20
напряжение питания, В: 5
интерфейс: I2C
размеры, мм: 98 x 60 x 12

Программное обеспечение:

Для работы с Ардуино необходимо:

«>

Подключаем дисплей LCD 1602 по i2c в XOD | Электрик по-жизни

Привет, друзья!

В прошлой статье мы рассмотрели параллельное подключение дисплея LCD 1602, сегодня рассмотрим подключение по i2c соединению.

I²C (IIC, англ. Inter-Integrated Circuit) — последовательная асимметричная шина для связи между интегральными схемами внутри электронных приборов. Использует две двунаправленные линии связи (SDA и SCL), применяется для соединения низкоскоростных периферийных компонентов с процессорами и микроконтроллерами (например, на материнских платах, во встраиваемых системах, в мобильных телефонах).

Википедия

Для последовательного подключения i2c, используется точно такой же дисплей, только с дополнительной платой, дающей возможность передавать данные по 2 пинам, что существенно расширяет возможности платы Ардуино, высвобождая дополнительные пины.

Дисплей с платой I2S

Дисплей с платой i2c можно купить готовый или купить плату i2c и впаять самому, сложного в этом ничего нет.

Подключается дисплей по последовательному соединению по таким схеме.

Схема подключения LCD 1602 по I2S

В программе XOD такой дисплей для последовательного подключения представлен нодой text-lcd-i2c-16×2

Описание ноды text-lcd-i2c-16×2

В инспекторе ноды нужно указать адрес подключения в строке ADDR, как правило для дисплеев LCD 1602 он 27.

Инспектор ноды text-lcd-i2c-16×2

В строках L1 и L2 пишется текст, остальное, думаю, понятно.

Для использования ноды в вашем проекте у вас должна быть установлена библиотека xod-dev/text-lcd, её нужно установить из библиотеки XOD. Кстати, за одним и библиотеки научимся подключать, пригодиться на будущее.

Открываем поиск библиотеки так.

Библиотека XOD

Используем меню File/Add Library… или кликаем по иконке Add Library и в появившейся поисковой строке вводим xod-dev/text-lcd, выбираем выпавшую библиотеку из списка.

Компилируйте патч, пробуйте.

Экспериментируйте!!!

Предыдущие статьи:

Подключаем дисплей LCD 1602 параллельно в XOD

Сделай сам. Действующая сигнализация без написания кода

Пожалуй самый важный блок в XOD

Аналоговые датчики и сервопривод

Сервопривод. Что за привод?

Потенциал потенциометра

Измеряем температуру с помощью Ардуино

Простая — не простая кнопка в Arduino

Реле SRD-05VDC и способы подключения в XOD

Спасибо, что дочитали статью до конца.

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

Понравилась статья, ставьте палец вверх.

Хотите следить за новостями, подписывайтесь на наш канал.

Впереди ещё много интересного!

Вы можете помочь проекту в развитии:

Работа Raspberry Pi Pico с модулем дисплея 16×2 LCD Display

В этой статье мы продолжаем изучать новинку этого года — микроконтроллер от Raspberry Pi Foundation на чипе собственной разработки RP2040 — Raspberry Pi Pico, выпущенный в начале 2021 года. Этот микроконтроллер можно применять в широком диапазоне проектов и инженерных приложений, а часто проекты связаны с выводом пользователю различной цифровой, символьной или графической информации, для чего и можно использовать модули дисплеев. К слову, Pico работает не только с выпущенными специально для него дисплеями (как это часто бывает с платами расширения для различных брендов) — он работает в том числе со стандартным интерфейсом I2C, что позволяет включать дисплеи в ряд с другими устройствами по последовательному протоколу, хотя давайте обо всём подробнее…

Целью данной статьи мы ставим изучение взаимодействия модуля жидкокристаллического дисплея 16×2 (16×2 LCD Display) с Raspberry Pi Pico.

LCD дисплей представляет собой электронный дисплейный модуль, в котором для создания видимого изображения используется жидкокристаллическая технология. Модуль 16×2 LCD Display — это один из простейших модулей такого типа, обычно используемый в электронных схемах для вывода цифровой и/или текстовой информации. Индекс 16×2 означает, что дисплей имеет 16 символов в строке в 2 таких строки по высоте экрана. Если рассматривать каждый символ LCD-дисплея, то он отображается в матрице 5×8 пикселей.

LCD-дисплей основан на драйвере HD44780. Существуют 2 версии этого LCD-дисплея: версия с I2C и версии без I2C. Мы возьмем обе версии этого дисплея в качестве примера, присоединим к Raspberry Pi Pico, а затем напишем код на MicroPython для взаимодействия LCD-дисплея 16×2 с Raspberry Pi Pico.

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

Микроконтроллер Raspberry Pi Pico
Модуль 16×2 LCD Display
Компьютер или планшет для написания кода
Кабель USB Type-A — MicroUSB для прошивки.

Обзор модуля дисплея 16×2 LCD Display.

Модуль 16×2 LCD Display назван так, потому что он имеет 16 столбцов и 2 строки. Таким образом, в нем будет всего (16 × 2 = 32) 32 символа, и каждый символ будет состоять из 5 × 8 пикселей. Одиночный символ со всеми его пикселями показан на рисунке ниже.

Каждый символ имеет (5 по горизонтали × 8 по вертикали = 40) 40 пикселей, а для 32 символов итого будет (32 × 40) 1280 пикселей. Кроме того, этот ЖК-дисплей также должен быть проинструктирован о положении пикселей. Справиться со всем этим с помощью только микроконтроллера будет сложной задачей, поэтому в ЖК-дисплее используется интерфейсный чип (интегральная схема), называемый драйвер или контроллер, модели HD44780. Подробнее об этом драйвере вы можете прочесть в оригинальном Руководстве от производителя HITACHI по ссылке: HD44780U (Dot MAtrix Liquid Crystal Display Controller/Driver). Этот драйвер установлена на задней стороне платы ЖК-модуля.

Функция драйвера — получать команды и данные от микроконтроллера (MCU) и обрабатывать их для отображения значимой информации на ЖК-экране. Рабочее напряжение ЖК-дисплея составляет от 4,7 В до 5,3 В, а потребление тока составляет 1 мА (без подсветки). Дисплей может работать как в 8-битном, так и в 4-битном режиме, а также может отображать любые созданные пользователем символы. Эти ЖК-дисплеи доступны с зеленой и синей подсветкой фона.

Версия модуля 16×2 LCD Display без I2C

На верхней части платы модуля ЖК-дисплея есть 16 контактов для передачи данных, управляющих команд и питания. Все вместе они участвуют в процессе правильного включения и отключения нужных пикселей экрана, а также включения LED-подсветки фона.

Версия модуля 16×2 LCD Display с I2C

Этот тип дисплея включает интерфейс I2C, для которого требуется только 2 контакта (SDA и SCL) для соединения с микроконтроллером. I2C (Inter-Integrated Circuit, IIC, I²C) — последовательная асимметричная шина, разработана фирмой Philips Semiconductors в начале 1980-х годов, для связи между интегральными схемами внутри электронных приборов. Она использует две двунаправленные линии связи: последовательную линию данных SDA (Serial DAta) и последовательную линию тактирования SCL (Serial CLock), и применяется для соединения низкоскоростных периферийных компонентов с процессорами и микроконтроллерами. Интерфейс I2C — это дополнительная плата (адаптер), прикрепленная к задней части ЖК-модуля и припаянная к 16 контактам на плате модуля дисплея. Адрес I2C для этих дисплеев — 0x3F или 0x27.

Адаптер имеет 8-битный чип расширения ввода / вывода PCF8574 производителя TI (Texas Instruments). С техническими данными этого чипа можно ознакомиться, перейдя по следующей ссылке: PCF8574 Remote 8-Bit I/O Expander for I 2C Bus.

Этот чип преобразует данные I2C от микроконтроллера в параллельные данные, необходимые для ЖК-дисплея. Есть небольшой подстроечный резистор для точной настройки контрастности дисплея (на картинке выше он синего цвета и имеет шлиц для вращения крестовой отвёрткой). Кроме того, на плате есть перемычка, подающая питание на подсветку (на противоположной от разъёма I2C стороне адаптера).

В чём же заключается преимущество использования адаптера с интерфейсом I2C для платы дисплея применительно к нашему микроконтроллеру Raspberry Pi Pico?

На этот вопрос ответить достаточно просто. Raspberry Pi Pico построен с использованием микроконтроллера RP2040. На его плате имеется 26 многофункциональных контактов GPIO из 36 контактов GPIO. 10 контактов GPIO не доступны для использования. Из 26 используемых контактов GPIO есть 2 пары контактов I2C.

Как было отмечено, синхронная несимметричная шина I2C (I2C Bus) последовательной связи с несколькими ведущими, несколькими ведомыми устройствами с коммутацией пакетов широко используется для присоединения низкоскоростных периферийных интегральных схем к процессорам и микроконтроллерам при передаче данных на короткие расстояния и внутри платы.

Как и связь UART, I2C использует только два провода для передачи данных между устройствами.

I2C Bus — cинхронная несимметричная шина I2C.

Device 1, Device 2, Device 3 — внешние устройства с интерыфейсом I2C.

SDA (Serial Data Line) — последовательная линия данных.

SCL (Serial Clock Line) — последовательная линия синхронизации.

Данные, подлежащие передаче, отправляются через провод SDA и синхронизируются с тактовым сигналом (clock signal) от SCL. Все устройства / интегральные схемы в сети I2C (I2C network) подключены к тем же линиям SCL и SDA, как показано выше.

Устройства, подключенные к шине I2C, являются либо ведущими (master), либо ведомыми (slave). В любой момент времени на шине I2C остается активным только один ведущий (мастер). Он управляет линией синхронизации SCL и решает, какая операция должна выполняться на линии данных SDA.

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

Когда ведущее устройство (master device) хочет передать данные на ведомое устройство (slave device) или от него, оно указывает этот конкретный адрес ведомого устройства в строке SDA, а затем приступает к передаче. Таким образом, между ведущим устройством и конкретным ведомым устройством происходит эффективная связь. Все остальные ведомые устройства не отвечают, если их адрес не указан ведущим устройством в строке SDA.

Микросхема микроконтроллера RP2040 имеет два контроллера I2C (см. схему выше), и к ним обоим можно получить доступ через контакты GPIO Raspberry Pi Pico. В следующей таблице показано подключение контактов GPIO к обоим контроллерам I2C.

Контроллер I2C	Разъёмы GPIO
I2C0 – SDA	GP0 / GP4 / GP8 / GP12 / GP16 / GP20
I2C0 – SCL	GP1 / GP5 / GP9 / GP13 / GP17 / GP21
I2C1 – SDA	GP2 / GP6 / GP10 / GP14 / GP18 / GP26
I2C1 – SCL	GP3 / GP7 / GP11 / GP15 / GP19 / GP27

Каждое соединение контроллера можно настроить через несколько контактов GPIO, как показано на схеме. Но перед использованием контроллера I2C вы должны настроить в программном обеспечении, какие выводы GPIO вы хотите использовать с конкретным контроллером I2C.

Особенности контактов Raspberry Pi Pico I2C:
Raspberry Pi Pico имеет чип RP2040, который поддерживает следующие функции:

Устройство может работать в режиме ведущего (Master Mode) или ведомого (Slave Mode) с адресом по умолчанию = 0x055.
Пины I2C имеют 3 режима скорости: стандартный (от 0 до 100 Кбит/с), быстрый (до 400 Кбит/с) и режим Fast Plus (до 1000 Кбит/с).
Он может передавать и принимать буферы (Buffers).
Его также можно использовать в режиме прерывания (interrupt) и DMA.

Для демонстрации примера подключения устройств по шине I2C приведём следующий пример:

В данной схеме подключено 3 разных устройства I2C к плате Pico: датчик MPU6050, 0,96-дюймовый OLED-дисплей и датчик BME680 (слева направо соответственно). Выводы SDA и SCL MPU6050, BME680 и OLED-дисплея подключены к общей линии I2C Raspberry Pi Pico. Имеется в наличии несколько контактов I2C, но все эти устройства можно подключить используя только одну пару контактов I2C Raspberry Pi Pico. Д данном случае это GPIO8 как SDA0 и GPIO9 как SCL0.

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

Включение в графической среде:

Нажимаем иконку малины в правом верхнем углу экрана и выбираем параметры -> Raspberry Pi Configuration:

Откроется окно настроек, выбираем вкладку Interfaces:

Во вкладке Interfaces выбираем enable (включено) для I2C:

Нажимаем ОК и теперь интерфейс включен.

Включение в терминале:

Настройка в терминале может понадобится, если мы, к примеру, подключаемся к Raspberry удалённо. Для настройки в терминале необходимо ввести с клавиатуры sudo raspi-config и нажать enter:

В открывшемся меню настроек, выбираем 5-й пункт Interfacing Options и нажимаем enter:

Откроется меню выбора интерфейсов, выбираем P5 I2C:

На вопрос отвечаем <Да>:

Готово. Интерфейс включен.

Теперь давайте вернёмся к вопросу подключения нашего модуля ЖК-дисплея к микроконтроллеру Pico.

Первый способ (для версии без I2C).

Подключите контакты 1, 5 и 16 ЖК-дисплея к GND Raspberry Pi Pico. Точно так же подключите контакты 2 и 15 ЖК-дисплея к контакту 5 В (Vbus) Raspberry Pi Pico. Подключите контакты 4, 6, 11, 12, 13, 14 ЖК-дисплея к контакту Raspberry Pi Pico GP16, GP17, GP18, GP19, GP20, GP21.

Для регулировки контрастности ЖК-дисплея подключите потенциометр 10кОм к контакту 3 ЖК-дисплея.

У нас получилось вот так:

Исходный код / программа.

Raspberry Pi Pico поддерживает программу на MicroPython для взаимодействия с ЖК-дисплеем 16 × 2. Вы можете использовать Thonny IDE или uPyCraft IDE для запуска кода MicroPython. Установка Thonny IDE была рассмотрена нами в предыдущей статье: Использование АЦП в Raspberry Pi Pico с примером на MicroPython.

Вот полный код для взаимодействия с ЖК-дисплеем 16х2 на драйвере HD44780 с Raspberry Pi Pico. Скопируйте код в IDE и сохраните его под именем main.py.

import machine

import utime

rs = machine.Pin(16,machine.Pin.OUT)

e = machine.Pin(17,machine.Pin.OUT)

d4 = machine.Pin(18,machine.Pin.OUT)

d5 = machine.Pin(19,machine.Pin.OUT)

d6 = machine.Pin(20,machine.Pin.OUT)

d7 = machine.Pin(21,machine.Pin.OUT)

def pulseE():

e.value(1)

utime.sleep_us(40)

e.value(0)

utime.sleep_us(40)

def send2LCD4(BinNum):

d4.value((BinNum & 0b00000001) >>0)

d5.value((BinNum & 0b00000010) >>1)

d6.value((BinNum & 0b00000100) >>2)

d7.value((BinNum & 0b00001000) >>3)

pulseE()

def send2LCD8(BinNum):

d4.value((BinNum & 0b00010000) >>4)

d5.value((BinNum & 0b00100000) >>5)

d6.value((BinNum & 0b01000000) >>6)

d7.value((BinNum & 0b10000000) >>7)

pulseE()

d4.value((BinNum & 0b00000001) >>0)

d5.value((BinNum & 0b00000010) >>1)

d6.value((BinNum & 0b00000100) >>2)

d7.value((BinNum & 0b00001000) >>3)

pulseE()

def setUpLCD():

rs.value(0)

send2LCD4(0b0011)#8 bit

send2LCD4(0b0010)#4 bit

send2LCD8(0b00101000)#4 bit,2 lines?,5*8 bots

send2LCD8(0b00001100)#lcd on, blink off, cursor off.

send2LCD8(0b00000110)#increment cursor, no display shift

send2LCD8(0b00000001)#clear screen

utime.sleep_ms(2)#clear screen needs a long delay

setUpLCD()

rs.value(1)

for x in ‘Hello World!’:

send2LCD8(ord(x))

В результате запуска этого кода ЖК-дисплей начнет показывать сообщение Hello World! на своём экране.

Второй способ (подключение через шину I2C).

Приведенный выше код действителен для ЖК-дисплея 16×2 без модуля I2C. Модуль PCF8574 I2C или SMBus намного упрощает указанное в предыдущем способе подключение. Вместо того, чтобы использовать такое большое количество проводов, можно использовать этот модуль и с помощью его интегральной схемы преобразовать все линии вывода данных только в 2 физических провода. По умолчанию ЖК-дисплей становится устройством I2C с адресом I2C 0x27. Соединение между Raspberry Pi Pico и ЖК-дисплеем I2C очень простое (см. схему):

Подключите вывод ЖК-дисплея VCC и GND к выводу Raspberry Pi Pico 5V и GND соответственно. Подключите выводы SDA и SCL ЖК-дисплея к Raspberry Pi Pico GP8 и GP9 соответственно.

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

Исходный код / программа.

Программа для данного вида подключения выглядит значительно сложнее и разделена на 3 части. Нам нужно написать код драйвера, а также код протокола I2C, чтобы подключить их в основном классе main.py.

Вам же просто необходимо скопировать весь этот код, а затем сохранить все 3 кода на Raspberry Pi Pico Board оответственно в файлы: lcd_api.py, pico_i2c_lcd.py, main.py.

lcd_api.py

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

import time

class LcdApi:

LCD_CLR = 0x01 # DB0: clear display

LCD_HOME = 0x02 # DB1: return to home position

LCD_ENTRY_MODE = 0x04 # DB2: set entry mode

LCD_ENTRY_INC = 0x02 # —DB1: increment

LCD_ENTRY_SHIFT = 0x01 # —DB0: shift

LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on

LCD_ON_DISPLAY = 0x04 # —DB2: turn display on

LCD_ON_CURSOR = 0x02 # —DB1: turn cursor on

LCD_ON_BLINK = 0x01 # —DB0: blinking cursor

LCD_MOVE = 0x10 # DB4: move cursor/display

LCD_MOVE_DISP = 0x08 # —DB3: move display (0-> move cursor)

LCD_MOVE_RIGHT = 0x04 # —DB2: move right (0-> left)

LCD_FUNCTION = 0x20 # DB5: function set

LCD_FUNCTION_8BIT = 0x10 # —DB4: set 8BIT mode (0->4BIT mode)

LCD_FUNCTION_2LINES = 0x08 # —DB3: two lines (0->one line)

LCD_FUNCTION_10DOTS = 0x04 # —DB2: 5×10 font (0->5×7 font)

LCD_FUNCTION_RESET = 0x30 # See «Initializing by Instruction» section

LCD_CGRAM = 0x40 # DB6: set CG RAM address

LCD_DDRAM = 0x80 # DB7: set DD RAM address

LCD_RS_CMD = 0

LCD_RS_DATA = 1

LCD_RW_WRITE = 0

LCD_RW_READ = 1

def __init__(self, num_lines, num_columns):

self.num_lines = num_lines

if self.num_lines > 4:

self.num_lines = 4

self.num_columns = num_columns

if self.num_columns > 40:

self.num_columns = 40

self.cursor_x = 0

self.cursor_y = 0

self.implied_newline = False

self.backlight = True

self.display_off()

self.backlight_on()

self.clear()

self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)

self.hide_cursor()

self.display_on()

def clear(self):

«»»Clears the LCD display and moves the cursor to the top left

corner.

«»»

self.hal_write_command(self.LCD_CLR)

self.hal_write_command(self.LCD_HOME)

self.cursor_x = 0

self.cursor_y = 0

def show_cursor(self):

«»»Causes the cursor to be made visible.»»»

self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |

self.LCD_ON_CURSOR)

def hide_cursor(self):

«»»Causes the cursor to be hidden.»»»

self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

def blink_cursor_on(self):

«»»Turns on the cursor, and makes it blink.»»»

self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |

self.LCD_ON_CURSOR | self.LCD_ON_BLINK)

def blink_cursor_off(self):

«»»Turns on the cursor, and makes it no blink (i.e. be solid).»»»

self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |

self.LCD_ON_CURSOR)

def display_on(self):

«»»Turns on (i.e. unblanks) the LCD.»»»

self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

def display_off(self):

«»»Turns off (i.e. blanks) the LCD.»»»

self.hal_write_command(self.LCD_ON_CTRL)

def backlight_on(self):

«»»Turns the backlight on.

This isn’t really an LCD command, but some modules have backlight

controls, so this allows the hal to pass through the command.

«»»

self.backlight = True

self.hal_backlight_on()

def backlight_off(self):

«»»Turns the backlight off.

This isn’t really an LCD command, but some modules have backlight

controls, so this allows the hal to pass through the command.

«»»

self.backlight = False

self.hal_backlight_off()

def move_to(self, cursor_x, cursor_y):

«»»Moves the cursor position to the indicated position. The cursor

position is zero based (i.e. cursor_x == 0 indicates first column).

«»»

self.cursor_x = cursor_x

self.cursor_y = cursor_y

addr = cursor_x & 0x3f

if cursor_y & 1:

addr += 0x40 # Lines 1 & 3 add 0x40

if cursor_y & 2: # Lines 2 & 3 add number of columns

addr += self.num_columns

self.hal_write_command(self.LCD_DDRAM | addr)

def putchar(self, char):

«»»Writes the indicated character to the LCD at the current cursor

position, and advances the cursor by one position.

«»»

if char == ‘\n’:

if self.implied_newline:

# self.implied_newline means we advanced due to a wraparound,

# so if we get a newline right after that we ignore it.

pass

else:

self.cursor_x = self.num_columns

else:

self.hal_write_data(ord(char))

self.cursor_x += 1

if self.cursor_x >= self.num_columns:

self.cursor_x = 0

self.cursor_y += 1

self.implied_newline = (char != ‘\n’)

if self.cursor_y >= self.num_lines:

self.cursor_y = 0

self.move_to(self.cursor_x, self.cursor_y)

def putstr(self, string):

«»»Write the indicated string to the LCD at the current cursor

position and advances the cursor position appropriately.

«»»

for char in string:

self.putchar(char)

def custom_char(self, location, charmap):

«»»Write a character to one of the 8 CGRAM locations, available

as chr(0) through chr(7).

«»»

location &= 0x7

self.hal_write_command(self.LCD_CGRAM | (location << 3))

self.hal_sleep_us(40)

for i in range(8):

self.hal_write_data(charmap[i])

self.hal_sleep_us(40)

self.move_to(self.cursor_x, self.cursor_y)

def hal_backlight_on(self):

«»»Allows the hal layer to turn the backlight on.

If desired, a derived HAL class will implement this function.

«»»

pass

def hal_backlight_off(self):

«»»Allows the hal layer to turn the backlight off.

If desired, a derived HAL class will implement this function.

«»»

pass

def hal_write_command(self, cmd):

«»»Write a command to the LCD.

It is expected that a derived HAL class will implement this

function.

«»»

raise NotImplementedError

def hal_write_data(self, data):

«»»Write data to the LCD.

It is expected that a derived HAL class will implement this

function.

«»»

raise NotImplementedError

def hal_sleep_us(self, usecs):

«»»Sleep for some time (given in microseconds).»»»

time.sleep_us(usecs)

pico_i2c_lcd.py

from lcd_api import LcdApi

from machine import I2C

from time import sleep_ms

DEFAULT_I2C_ADDR = 0x27

# Defines shifts or masks for the various LCD line attached to the PCF8574

MASK_RS = 0x01

MASK_RW = 0x02

MASK_E = 0x04

SHIFT_BACKLIGHT = 3

SHIFT_DATA = 4

class I2cLcd(LcdApi):

«»»Implements a character based lcd connected via PCF8574 on i2c.»»»

def __init__(self, i2c, i2c_addr, num_lines, num_columns):

self.i2c = i2c

self.i2c_addr = i2c_addr

self.i2c.writeto(self.i2c_addr, bytearray([0]))

sleep_ms(20) # Allow LCD time to powerup

# Send reset 3 times

self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)

sleep_ms(5) # need to delay at least 4.1 msec

self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)

sleep_ms(1)

self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)

sleep_ms(1)

# Put LCD into 4 bit mode

self.hal_write_init_nibble(self.LCD_FUNCTION)

sleep_ms(1)

LcdApi.__init__(self, num_lines, num_columns)

cmd = self.LCD_FUNCTION

if num_lines > 1:

cmd |= self.LCD_FUNCTION_2LINES

self.hal_write_command(cmd)

def hal_write_init_nibble(self, nibble):

«»»Writes an initialization nibble to the LCD.

This particular function is only used during intiialization.

«»»

byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA

self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))

self.i2c.writeto(self.i2c_addr, bytearray([byte]))

def hal_backlight_on(self):

«»»Allows the hal layer to turn the backlight on.»»»

self.i2c.writeto(self.i2c_addr, bytearray([1 << SHIFT_BACKLIGHT]))

def hal_backlight_off(self):

«»»Allows the hal layer to turn the backlight off.»»»

self.i2c.writeto(self.i2c_addr, bytearray([0]))

def hal_write_command(self, cmd):

«»»Writes a command to the LCD.

Data is latched on the falling edge of E.

«»»

byte = ((self.backlight << SHIFT_BACKLIGHT) | (((cmd >> 4) & 0x0f) << SHIFT_DATA))

self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))

self.i2c.writeto(self.i2c_addr, bytearray([byte]))

byte = ((self.backlight << SHIFT_BACKLIGHT) | ((cmd & 0x0f) << SHIFT_DATA))

self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))

self.i2c.writeto(self.i2c_addr, bytearray([byte]))

if cmd <= 3:

# The home and clear commands require a worst case delay of 4.1 msec

sleep_ms(5)

def hal_write_data(self, data):

«»»Write data to the LCD.»»»

byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | (((data >> 4) & 0x0f) << SHIFT_DATA))

self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))

self.i2c.writeto(self.i2c_addr, bytearray([byte]))

byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | ((data & 0x0f) << SHIFT_DATA))

self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))

self.i2c.writeto(self.i2c_addr, bytearray([byte]))

Ну и основную программу:

main.py

from pico_i2c_lcd import I2cLcd

from machine import I2C

from machine import Pin

import utime as time

i2c = I2C(id=1,scl=Pin(9),sda=Pin(8),freq=100000)

lcd = I2cLcd(i2c, 0x27, 2, 16)

while True:

lcd.move_to(2,0)

lcd.putstr(‘Hello world’)

Как только вы запустите все эти коды на Raspberry Pi Pico, на ЖК-дисплее появится сообщение Hello World!

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

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

UART против I2C против SPI — протоколы связи и их использование

Когда мы говорим о протоколах связи, UART, SPI и I2C являются общими аппаратными интерфейсами, которые люди используют при разработке микроконтроллеров.

В этой статье сравниваются различные интерфейсы: UART, SPI и I2C, а также их различия. Мы будем сравнивать их с различными факторами на основе их протоколов, преимуществ и недостатков каждого интерфейса и т. Д., И мы предоставим несколько примеров того, как эти интерфейсы используются в микроконтроллерах.

Интерфейс UART

Что такое UART?

Означает Универсальный асинхронный прием и передача (UART)
Простой протокол последовательной связи, который позволяет хосту обмениваться данными с дополнительным устройством.
UART поддерживает двунаправленную, асинхронную и последовательную передачу данных.
Он имеет две линии данных, одну для передачи (TX), а другую для приема (RX), которые используются для связи через цифровой контакт 0, цифровой контакт 1.
TX и RX подключены между двумя устройствами. (например, USB и компьютер)
UART также может обрабатывать проблемы управления синхронизацией между компьютерами и внешними последовательными устройствами.

Как это работает?

Он может работать между устройствами тремя способами:
- Симплекс = передача данных в одном направлении
- Полудуплекс = передача данных в любом направлении, но не одновременно
- Полнодуплексный = передача данных в обоих направлениях одновременно
После подключения данные проходят от TX передающего UART к RX принимающего UART.
Поскольку UART является протоколом асинхронной последовательной передачи = Нет часов
Передача UART преобразует параллельные данные от ведущего устройства (например, CPU) в последовательную форму и передает их последовательно в принимающий UART. Затем он преобразует последовательные данные обратно в параллельные данные для принимающего устройства

Ссылка: Основы связи UART.

Поскольку UART не имеет часов, UART добавляет стартовые и стоповые биты, которые передаются для представления начала и конца сообщения.
Это помогает принимающему UART знать, когда начинать и останавливать чтение битов. Когда принимающий UART обнаруживает стартовый бит, он будет читать биты с определенной скоростью передачи BAUD.
Скорость передачи данных UART называется скоростью передачи данных в формате BAUD и по умолчанию установлена на 115200 (скорость передачи данных в формате BAUD основана на скорости передачи символов, но аналогична скорости передачи в битах).
Оба UART должны работать примерно с одинаковой скоростью передачи. Если разница в скорости передачи данных в формате BAUD превышает 10%, синхронизация битов может быть отключена и данные станут непригодными для использования.Пользователь должен убедиться, что UART настроены для передачи и приема одного и того же пакета данных.

Рабочий протокол UART

UART, который передает данные, сначала получит данные от шины данных, которые отправляются другим компонентом (например, CPU).
После получения данных из шины данных он добавит стартовый бит, бит четности и стоповый бит для создания пакета данных.
Пакет данных затем передается на вывод TX, где принимающий UART будет читать пакет данных на своем выводе RX.Данные отправляются до тех пор, пока в передающем UART не останется данных.

Передача и получение данных

Когда данные передаются по передающему FIFO, флаг FIFO «BUSY» будет установлен и активен во время процесса.
- FIFO = первым пришел — первым ушел. Это буфер UART, который заставляет последовательно передавать каждый байт принимающему UART.
Бит «ЗАНЯТО» будет неактивен только после того, как передача данных закончится, FIFO очищается и все биты были переданы, включая стоповый бит.
Когда приемник UART находится в режиме ожидания и если на входе данных низкий уровень после получения стартового бита, счетчик приема начнет работать и будет ожидать получения данных в 8-м цикле BAUD16.
Если RX все еще находится на низком уровне в течение 8-го цикла Baud16, в то время как стартовый бит действителен, он будет обработан как неправильный стартовый бит и, таким образом, проигнорирован.
Если стартовый бит действителен, биты данных выбираются каждый 16-й цикл Baud16 в зависимости от длины символа данных. Если включен режим четности, также определяется бит четности.
Если RX высокий, будет подтвержден действительный стоповый бит. В противном случае произойдет ошибка кадрирования.
Когда получен полный пакет данных, данные сохраняются в принимающем FIFO.

Управление прерываниями

Целью прерываний является автоматическая отправка содержимого буфера.
Пользователь может использовать прерывания в следующих случаях:
- Ошибка разрыва строки (сигнал RX остается 0, включая контрольный и стоповый бит.)
- Ошибка кадра (стоповый бит не 1)
- Тайм-аут приема ( приемный FIFO имеет данные, но не полные, и последующие данные не передаются)

Операция FIFO

Модуль UART семейства процессоров ARM Stellaris содержит два 16-байтовых FIFO: один для передачи и один для приема.
Их можно настроить на запуск прерываний на разной глубине. Например, глубина 1/8, 1/4, 1/2, 3/4 и 7/8.
Если принимающий FIFO запускает прерывание на 1/4, прерывание приема запускается, когда UART получает 4 данных.

Рабочий процесс передачи FIFO:

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

Рабочий процесс приема FIFO:

Когда оборудование получает данные, они сохраняются в принимающем FIFO. Программа будет автоматически извлекать и стирать данные из принимающего FIFO, поэтому в принимающем FIFO останется место.Если данные в принимающем FIFO не стираются, а принимающий FIFO заполнен, данные будут потеряны.
FIFO приемопередатчика предназначен для решения проблемы, связанной с неэффективностью ЦП и слишком частым прерыванием работы приемопередатчика UART. Используя связь UART, режим прерывания проще и эффективнее, чем метод опроса. Без FIFO приемопередатчика все данные будут прерваны один раз и станут неэффективными. С FIFO приемопередатчика он может генерировать прерывание и постоянно передавать и принимать данные (до 14), что повышает эффективность передачи и приема.
Потеря данных не произойдет в результате FIFO, поскольку он уже предвидел какие-либо проблемы в процессе отправки и получения. Пока UART инициализирован, процедура прерывания будет делать все автоматически.

Петля

UART имеет внутреннюю функцию обратной петли для диагностики или отладки, когда данные, отправленные из TX, будут приняты входом RX.

Последовательный инфракрасный протокол

UART имеет последовательный порт IrDA Модуль инфракрасного (SIR) кодера / декодера.Модуль IrDA SIR переводит между асинхронным потоком данных UART и полудуплексным последовательным интерфейсом SIR.
Используется для обеспечения цифровой кодированный выход и декодированный вход для UART. Сигнальный контакт UART может быть подключен к инфракрасному трансиверу для физического уровня IrDA SIR связь.

Преимущества использования UART

Прост в использовании, хорошо документирован, поскольку это широко используемый метод с большим количеством ресурсов в Интернете
Часы не требуются
Бит четности для проверки ошибок

Недостатки использования UART

Размер кадра данных ограничен всего 9 битами
Невозможно использовать несколько ведущих систем и ведомых устройств
Скорости передачи каждого UART должны быть в пределах 10% друг от друга, чтобы предотвратить потерю данных.
Низкая скорость передачи данных

Примеры UART в микроконтроллерах:

USB CP2102 Последовательный преобразователь

Высокоинтегрированный контроллер моста USB-UART, обеспечивающий простое решение для обновления конструкций RS-232 до USB с использованием минимального количества компонентов и места на печатной плате. Он обеспечивает USB-подключение к устройствам с интерфейсом UART.
- Он использует стандартный USB-штекер типа A и 6-контактный разъем TTL.
Этот последовательный преобразователь USB CP2102 представляет собой небольшой адаптер для платы Arduino / Seeeduino для приема обновлений прошивки с компьютера.

FT232r USB UART / USB к UART 5 В

Компания Seeed предлагает аналогичный продукт: USB-UART 5V
Это USB-последовательный интерфейс UART, который упрощает USB-порт для последовательного подключения.
Уменьшает количество внешних компонентов, при этом эффективно работая с хост-контроллером USB, используя как можно меньше общей доступной полосы пропускания USB.
Для USB в UART 5V он основан на Ch440, который представляет собой микросхему преобразования шины USB и может реализовать преобразование USB в последовательный интерфейс.
- Этот USB-порт преобразуется в инфракрасный порт IrDA или USB-порт для преобразования в интерфейс принтера, а также может использоваться для загрузки кода или связи с микроконтроллерами.

UART Seeeduino V4.2

Все платы Arduino имеют как минимум один последовательный порт (UART), который обменивается данными на цифровых выводах 0 (RX) и 1 (TX), а также с компьютером через USB.
Это Arduino-совместимая плата, основанная на микроконтроллере ATmga328P. С ATMEGA16U2 в качестве преобразователя UART-USB, плата может в основном работать как микросхема FTDI, и ее можно программировать через кабель micro-USB.

Базовый щит V2

Arduino Uno — самая популярная плата Arduino на данный момент, однако иногда бывает неприятно, когда вашему проекту требуется много датчиков или светодиодов, а ваши перемычки находятся в беспорядке.
Назначение этого продукта — избавиться от макетной платы и соединительных проводов. Благодаря богатым разъемам Grove на плинтусе вы можете очень удобно добавлять все модули Grove в Arduino Uno!
Эти устройства могут быть подключены через UART и I2C (следующее коммуникационное периферийное устройство, о котором я расскажу!)

Интерфейс I2C

Что такое I2C?

Обозначает Межинтегральная схема (I2C)
Это протокол последовательной связи, аналогичный UART.Однако он не используется для связи ПК с устройством, а вместо этого используется с модулями и датчиками.
Это простая двунаправленная двухпроводная синхронная последовательная шина, для которой требуется только два провода для передачи информации между устройствами, подключенными к шине.
Они полезны для проектов, требующих совместной работы множества различных частей (например, датчиков, выводов, расширений и драйверов), поскольку они могут подключать до 128 устройств к материнской плате, сохраняя при этом чистый канал связи!
Это связано с тем, что I2C использует адресную систему и общую шину = множество различных устройств могут быть подключены с использованием одних и тех же проводов, и все данные передаются по одному проводу и имеют небольшое количество контактов.Однако недостатком этого упрощенного подключения является то, что он медленнее, чем SPI.
Скорость I2C также зависит от скорости передачи данных, качества проводов и внешнего шума.
Протокол I2C также используется в качестве двухпроводного интерфейса для подключения низкоскоростных устройств, таких как микроконтроллеры, EEPROM, аналого-цифровые и цифро-аналоговые преобразователи. , Интерфейсы ввода-вывода и другие подобные периферийные устройства во встроенных системах.

Как это работает?

Он имеет 2 линии: SCL (последовательная линия синхронизации) и SDA (порт приема последовательной линии данных).
CL — линия синхронизации для синхронизации передачи.SDA — это линия данных, по которой отправляются или принимаются биты данных.
Ведущее устройство инициирует передачу данных по шине и генерирует часы, чтобы открыть переданное устройство, и любое адресуемое устройство считается ведомым устройством.
Взаимосвязь между ведущим и ведомым устройствами, передающими и принимающими по шине, непостоянна. Это зависит от направления передачи данных в данный момент.
Если ведущее устройство хочет отправить данные ведомому устройству, оно должно сначала обратиться к ведомому, прежде чем отправлять какие-либо данные.
Мастер завершит передачу данных. Если ведущее устройство хочет получить данные от ведомого, ведущее устройство должно снова сначала обратиться к ведомому.
Затем хост принимает данные, отправленные подчиненным, и, наконец, получатель завершает процесс приема. Хост также отвечает за генерацию тактовых импульсов и прекращение передачи данных.
Также необходимо подключить питание через подтягивающий резистор. Когда шина простаивает, обе линии работают с высоким уровнем мощности.
Емкость линии влияет на скорость передачи данных по шине. Поскольку текущая мощность на шине мала, слишком большая емкость может вызвать ошибки передачи. Таким образом, его нагрузочная способность должна составлять 400 пФ, чтобы можно было оценить допустимую длину шины и количество подключенных устройств.

Рабочий протокол I2C

Метод передачи данных

Ведущее устройство отправляет сигнал передачи каждому подключенному ведомому устройству, переключая линию SDA с высокого уровня напряжения на низкий уровень и линию SCL с высокого на низкий уровень после переключения линии SDA.
Ведущее устройство отправляет каждому ведомому устройству 7 или 10-битный адрес ведомого устройства и бит чтения / записи ведомому устройству, с которым он хочет связаться.
Подчиненное устройство затем сравнит адрес со своим собственным. Если адрес совпадает, ведомое устройство возвращает бит ACK, который переключает линию SDA на низкий уровень на один бит. Если адрес не совпадает с его адресом, ведомое устройство оставляет линию SDA на высоком уровне
Затем ведущее устройство отправляет или принимает фрейм данных. После передачи каждого кадра данных принимающее устройство возвращает отправителю еще один бит ACK, чтобы подтвердить успешную передачу.
Чтобы остановить передачу данных, ведущий отправляет сигнал остановки ведомому, переключая высокий уровень SCL перед переключением высокого уровня SDA

Синхронизация часов

Все мастера генерируют свои собственные часы на линии SCL для передачи сообщений на Шина I2C.
Данные действительно только в высокий период времени.
Часы синхронизация осуществляется подключением интерфейса I2C к линии SCL где переключатель идет с высокого на низкий. Когда часы устройства идут на низком уровне, он удерживает линию SCL в этом состоянии до тех пор, пока не достигнет высокого уровня Часы.
Если другие часы все еще находятся в низком периоде, переключатель низкого-высокого не изменяется состояние линии SCL. Линия SCL всегда удерживается на низком уровне устройством с самый продолжительный низкий период. На этот раз устройство с коротким и низким период перейдет в состояние высокого и ожидания.
Когда все соответствующие устройства завершили свой низкий период, линия часов идет высокий.
После что нет разницы в состоянии часов устройства и линии SCL, и все устройства начинают отсчитывать свой высокий период.Устройство, которое первое завершение периода максимума снова потянет за минимум линии SCL.
низкий период синхронных часов SCL определяется устройством с самый длинный низкий тактовый период, в то время как высокий период определяется устройством с самым коротким высоким тактовым периодом.

Режимы передачи

Быстрый режим:

Устройства быстрого режима могут принимать и передавать со скоростью 400 кбит / с. Они должны быть способны синхронизироваться с передачей 400 кбит / с и увеличивать низкий период сигнала SCL, чтобы замедлить передачу.
Устройства быстрого режима обратно совместимы и могут обмениваться данными с устройствами стандартного режима от 0 до 100 кбит / с шинными системами I2C. Однако, поскольку устройства в стандартном режиме несовместимы снизу вверх, они не могут работать в системе быстрой шины I2C. Спецификация шины I2C для быстрого режима имеет следующие характеристики по сравнению со стандартным режимом:
- Максимальная скорость передачи данных увеличена до 400 кбит / с;
- Скорректирована синхронизация сигналов последовательных данных (SDA) и последовательных часов (SCL).
- Имеет функцию подавления сбоев, а входы SDA и SCL имеют триггеры Шмитта.
- Выходной буфер имеет функцию управления крутизной для спадающих фронтов сигналов SDA и SCL
- После отключения питания устройства быстрого режима контакты ввода / вывода SDA и SCL должны быть остался без дела и не может заблокировать автобус.
- Внешнее подтягивающее устройство, подключенное к шине, должно быть настроено на максимально короткое максимально допустимое время нарастания шины I2C в быстром режиме.Для шин с максимальной нагрузкой 200 пФ подтягивающим устройством каждой шины может быть резистор. Для шины с нагрузкой от 200 пФ до 400 пФ подтягивающим устройством может быть источник тока (максимум 3 мА) или цепь переключаемого резистора.

Высокоскоростной режим:

Устройства в режиме Hs могут передавать информацию со скоростью до 3,4 Мбит / с и оставаться полностью обратно совместимыми с устройствами в быстром режиме или стандартном режиме (режим F / S), которые могут обмениваться данными в двух направлениях в системе со смешанной скоростью.
Передача в режиме Hs имеет тот же принцип последовательной шины и формат данных, что и система в режиме F / S, за исключением арбитража и тактовой синхронизации, которые не выполняются.
Спецификация шины I2C в высокоскоростном режиме выглядит следующим образом:
- В высокоскоростном режиме (Hs) ведущее устройство имеет выходной буфер с открытым стоком для высокоскоростного сигнала (SDAH) и вытягивание с открытым стоком. — цепь понижения и повышения напряжения источника тока на выходе высокоскоростной последовательной синхронизации (SCLH). Это сокращает время нарастания сигнала SCLH, и в любой момент активен только один источник тока хоста;
- В режиме Hs системы с несколькими ведущими не выполняются арбитраж и тактовая синхронизация, чтобы ускорить возможность обработки битов.Процесс арбитража обычно заканчивается после того, как код хоста передан в режиме F / S.
- Ведущее устройство в режиме Hs генерирует последовательный тактовый сигнал высокого и низкого уровня с соотношением 1: 2, что устраняет временные требования для времени установки и удержания.
- Устройство, работающее в режиме HS, может иметь встроенный мост. Во время передачи в режиме Hs линии SDAH и SCLH устройства в режиме Hs отделены от линий SDA и SCL, что снижает емкостную нагрузку линий SDAH и SCLH и ускоряет рост и падение.
- Разница между подчиненными устройствами в режиме Hs и подчиненными устройствами F / S заключается в скорости, с которой они работают.
- Устройство режима Hs может подавлять выбросы, а выходы SDAH и SCLH также имеют триггер Шмитта;
- Выходной буфер устройства режима Hs имеет функцию управления крутизной спада для сигналов SDAH и SCLH.

Преимущества использования I2C

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

Недостатки использования I2C

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

Примеры I2C в микроконтроллерах

Grove — концентратор I2C (6 портов)

I2C — очень популярный протокол связи. В системе Grove I2C используется более чем 80 датчиками для связи, 19 из которых связаны с мониторингом окружающей среды.
Сегодня все больше и больше микроконтроллеров используют уровни связи 3,3 В, но традиционный ArduinoUno по-прежнему использует 5 В, что приводит к необходимости выравнивания многих модулей, особенно сенсорных модулей, при их использовании.
Мы действительно работали над этой областью, и теперь большинство сенсорных модулей Grove имеют функцию сдвига уровня, и пользователям не нужно учитывать использование микроконтроллера 3,3 В или 5 В при его использовании. Это соответствует девизу Гроув: плагин, и используйте его, это так просто. Для более подробного обзора совместимости датчиков вы можете просмотреть наше Руководство по выбору Grove.

4-канальный 16-разрядный АЦП для Raspberry Pi (ADS1115)

Этот продукт от Seeed полностью совместим с Raspberry Pi.
Используется для Raspberry Pi без аналого-цифрового преобразователя или когда вам нужен более точный АЦП.
Мы предоставляем 4-канальный 16-разрядный АЦП для Raspberry Pi (ADS1115) через I2C, 4-канальный АЦП на базе Texas Instrument ADS1115, который представляет собой высокоточный 16-разрядный чип АЦП с низким энергопотреблением.

I2C Ардуино

Связь I2C также может использоваться между двумя платами Arduino.
Используется только для связи на короткие расстояния и использует синхронизированный тактовый импульс.
В основном используется для связи с датчиками или другими устройствами, которые должны отправлять информацию мастеру.

Драйвер I2C / Легко управляемый адаптер Устройства I2C

Драйвер I²C — это простой в использовании инструмент с открытым исходным кодом для управления устройствами I²C. Он работает с Windows, Mac и Linux и имеет встроенный цветной экран, на котором в реальном времени отображается вся деятельность I²C.
Благодаря встроенному дисплею, отображающему тепловую карту всех активных сетевых узлов, вы можете наблюдать из сети I²C с несколькими устройствами, какие из них являются наиболее активными.

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

MCP 23017

Ссылка: Electronicwings, 16-разрядный расширитель GPIO MCP23017.

16-битное расширение параллельного ввода-вывода общего назначения для шины I2C. Аналогичен MCP23S17, за исключением последовательного интерфейса (I2C против SPI).
Расширитель портов, который предоставляет пользователю практически идентичные порты по сравнению со стандартными микроконтроллерами.

PCF 8574

Ссылка: PCF8574 Плата модуля последовательного интерфейса, преобразователь ЖК-дисплея.

Обеспечивает расширение удаленного ввода-вывода общего назначения через двухпроводную двунаправленную шину I2C (последовательные часы (SCL), последовательные данные (SDA)).
Seeed будет использовать это в наших будущих продуктах, внимательно следите за ним!

Grove Base Hat для Raspberry Pi

Что такое роща?
- Это модульная стандартизированная система прототипирования соединителей.При сборке электроники Grove использует конструктивный подход. что упрощает подключение, экспериментирование и создание, а также упрощает систему обучения.
Сегодня серия датчиков, исполнительных механизмов и дисплеев Grove выросла в большое семейство, и сегодня мы представляем Raspberry Pi для всей системы Grove.
Базовая шляпа Grove для Raspberry Pi предоставляет цифровой / аналоговый / I2C / PWM / UART порт для удовлетворения всех ваших потребностей.
С помощью встроенного MCU для Raspberry Pi также доступен 12-битный 8-канальный АЦП.В настоящее время более 60 Groves поддержали Grove Base Hat для Raspberry Pi.

Интерфейс SPI

Что такое SPI?

Означает Последовательный периферийный интерфейс (SPI)
Он похож на I2C и представляет собой другую форму протокола последовательной связи, специально разработанную для подключения микроконтроллеров.
Работает в полнодуплексном режиме, когда данные можно отправлять и получать одновременно.
Работать на более высоких скоростях передачи данных = 8 Мбит или больше
Обычно это быстрее, чем I2C из-за простого протокола.Даже если линии данных / часов используются совместно между устройствами, каждому устройству потребуется уникальный адресный провод.
Используется там, где важна скорость. (например, SD-карты, модули дисплея или когда информация обновляется и быстро меняется, как термометры)

Как это работает?

Обменивайтесь двумя способами:
1. Выбор каждого устройства строкой Chip Select. Для каждого устройства требуется отдельная строка Chip Select. Это наиболее распространенный способ, которым в настоящее время RPi использует SPI.
2. Гирляндное соединение, при котором каждое устройство подключается к другому через свои данные, поступающие к данным в строке следующего.
Количество подключаемых устройств SPI не ограничено. Однако существуют практические ограничения из-за количества линий выбора оборудования, доступных на главном устройстве с помощью метода выбора микросхемы, или сложности передачи данных через устройства в методе последовательного подключения.
При двухточечной связи интерфейс SPI не требует операций адресации и является полнодуплексным, что является простым и эффективным.

Рабочий протокол SPI

SPI обменивается данными через 4 порта, а именно:
- MOSI — вывод основных данных, ввод данных ведомого
- MISO — ввод данных ведущего, вывод данных ведомого
- SCLK — тактовый сигнал, генерируемый ведущим устройством, до fPCLK / 2, частота ведомого режима до fCPU / 2
- NSS — сигнал с включенным ведомым устройством, управляемый ведущим устройством, некоторые ИС будут помечены как CS (выбор микросхемы)
В мульти-ведомом В системе каждое ведомое устройство требует отдельного разрешающего сигнала, что немного сложнее с точки зрения оборудования, чем система I2C.
Интерфейс SPI на самом деле представляет собой два простых сдвиговых регистра во внутреннем оборудовании. Передаваемые данные 8 бит. Он передается бит за битом под сигналом включения ведомого и импульсом сдвига, генерируемым ведущим устройством. Старший бит находится спереди, а младший — сзади.
Интерфейс SPI — это синхронная последовательная передача данных между ЦП и периферийным низкоскоростным устройством. Под импульсом сдвига ведущего устройства данные передаются бит за битом. Старший бит находится спереди, а младший — сзади.Это полнодуплексная связь, и скорость передачи данных в целом выше, чем у шины I2C, и может достигать скорости в несколько Мбит / с.

Преимущества использования SPI

Протокол прост, поскольку нет сложной системы адресации ведомых устройств, такой как I2C.
Это самый быстрый протокол по сравнению с UART и I2C.
Нет стартовых и стоповых битов, в отличие от UART, что означает, что данные могут передаваться непрерывно без прерывания
Отдельные линии MISO и MOSI, что означает, что данные могут передаваться и приниматься одновременно

Недостатки использования SPI

Больше портов Pin занято, практическое ограничение на количество устройств.
Не указано управление потоком, и механизм подтверждения не подтверждает, получены ли данные, в отличие от I2C
Использует четыре строки — MOSI, MISO, NCLK, NSS
Нет формы проверки ошибок в отличие от UART (с использованием бита четности)
Всего 1 мастер

Примеры SPI в микроконтроллерах:

MCP 3008 / Grove I2C АЦП

Seeed предлагает аналогичный продукт, который имеет те же функции: Grove I2C ADC, но его коммуникационная периферия — I2C.
Это 10-битный 8-канальный аналого-цифровой преобразователь (АЦП).
Для MCP 3008 он подключается к Raspberry Pi через последовательное соединение SPI. Выполняется с помощью аппаратной шины SPI или любых четырех контактов GPIO и программного SPI для подключения к MCP 3008.

Последовательный модуль CAN-BUS на базе MCP2551 и MCP2515

Этот видимый продукт: Модуль последовательной шины CAN предоставляет вашему Arduino возможности шины CAN и позволяет взломать ваш автомобиль. Он позволяет читать и записывать сообщения на шину CAN.
Шина CAN — это система протоколов обмена сообщениями, которая позволяет различным микроконтроллерам и датчикам в автомобиле общаться друг с другом. CAN обеспечивает междугородную, среднюю скорость передачи данных и высокую надежность.
Этот модуль последовательной шины CAN также может быть подключен к вашей Arduino через встроенный разъем Grove.
Интерфейсы с микроконтроллерами по SPI.

SPI Seeeduino V4.2

Последовательная связь SPI может использоваться с Arduino для связи между двумя Arduino, где один Arduino будет действовать как ведущий, а другой — как ведомый.
Используется для связи на короткие расстояния на высокой скорости.
Это тот же продукт: Arduino v4.2 из приведенного выше примера UART

ENC28J60 НАКЛАДКА ДЛЯ Raspberry pi

Pi zero ENC28J60 — это простой сетевой адаптер для Pi zero, который очень легко собрать и настроить.
Это позволяет вашему Raspberry Pi zero беспрепятственно получать доступ к сети, а также легко выполнять обновления системы и операции по установке программного обеспечения.
Microchip ENC28J60 — это 28-контактный автономный контроллер Ethernet 10BASE-T с интерфейсом SPI.
Интерфейс SPI служит каналом связи между хост-контроллером и ENC28J60.

Драйвер SPI / Адаптер — простой драйвер для устройств SPI

Это аналогичный продукт I2C Driver / Adapter-Easy Driver I2C Device, но для SPI. Это простой в использовании инструмент для управления устройствами SPI. Он работает с Windows, Mac и Linux и имеет встроенный цветной экран, на котором в реальном времени отображается логический анализатор всего трафика SPI.
Точно так же он использует стандартный последовательный USB-чип FTDI для связи с ПК, поэтому установка специальных драйверов не требуется.На плате имеются блоки питания 3,3 и 5 В с контролем напряжения и тока.

Флэш-память SPI очень распространена, и с помощью тестового зажима SPIDriver позволяет удобно считывать и записывать флэш-память SPI в цепи. Короткий скрипт — это все, что нужно для чтения или записи вспышки Atmel, а светодиодные ленты SPI также легко подключить к драйверу SPI. Вы также можете управлять ими напрямую, что делает их намного более увлекательными!
Использование SPI в этом разделе достаточно быстро для плавной анимации длинных полос и достижения эффектов POV.Короткие полоски также могут получать питание напрямую от мощного встроенного источника питания SPIDriver на 470 мА.

Итак, какое из этих коммуникационных периферийных устройств является «лучшим»? UART, SPI или I2C?

К сожалению, «лучшей» коммуникационной периферии нет. У каждого коммуникационного периферийного устройства есть свои преимущества и недостатки.

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

Сводка

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

Протокол	UART	I2C	SPI
Сложность	Простой	Простое объединение нескольких устройств в цепочку	Комплекс как устройство увеличивается
Скорость	Самый медленный	быстрее, чем UART	Самый быстрый
Кол-во устройств	До 2 устройств	До 127, но усложняется	Много, но усложняется
Количество жил	1	2	4
Дуплекс	Полный дуплекс	полудуплекс	Полный дуплекс
No.мастеров и рабов	от одного к одному	Несколько ведомых и ведущих	1 главный, несколько подчиненных

Эксклюзивное предложение!

Seeed предлагает одну бесплатную макетную плату для каждого клиента. Примените код BREADBOARD, чтобы получить одну бесплатную макетную плату (4,90 доллара США) в Seeed!

Следите за нами и ставьте лайки:

Читать дальше

Amazon.com: Модуль дисплея PEMENOL 5PCS OLED для Arduino, 0.96-дюймовый I2C IIC последовательный 128 x 64 OLED ЖК-дисплей с драйвером SSD1306 для Raspberry Pi и ESP8266

5.0 из 5 звезд Превосходные дисплеи — намного лучше, чем старые символьные ЖК-дисплеи!
Бенджамин Д. Холл, 20 августа 2019 г.

Когда я впервые начал программировать микроконтроллеры 20 лет назад, единственным вариантом, который у вас был для дисплея, был символьный жидкокристаллический дисплей (ЖКД) или несколько 8-символьных светодиодных дисплеев.ЖК-дисплеи были дорогими, они были маленькими, может быть, две строки по 16 символов в строке, и их подключение к микроконтроллеру занимало большую часть ваших входных / выходных контактов, оставляя вам очень мало контактов для других ваших потребностей ввода / вывода. 8-символьные светодиоды отлично подходят для цифр, но ужасны для текста. Сделать какую-либо графику на любом из них было довольно сложно. ЖК-дисплеи с подсветкой были еще дороже и потребляли МНОГО тока. Встраивать их в проект было сложно, и результат не выглядел визуально привлекательным, это выглядело, ну, ну, как хобби-проект.

Теперь, в 2019 году, у нас есть эти потрясающие дисплеи на органических светодиодах (OLED) SSD1306, которые решают все эти проблемы! Давайте посмотрим, как они это делают:

Стоимость. Я купил пять дисплеев за 22,99 доллара на момент написания этого обзора (август 2019 года), и с Prime они были отправлены мне бесплатно. Это хорошо сделанные дисплеи хорошего качества, поэтому низкая стоимость не идет в ущерб качеству. Они поставляются с предварительно смонтированным четырехконтактным разъемом — дисплей можно подключить к макетной плате (как я сделал на фотографиях) или подключить перемычками DuPont.

Размер. Хотя эти дисплеи небольшие, примерно 27 мм в квадрате (или примерно 1,125 дюйма в квадрате), они являются графическими дисплеями, и вы можете выбрать размер своего символа. На первой фотографии выше мне удалось уместить семь строк текста, примерно по 20 символов в строке. Это примерно 140 символов! Если вам нужны символы большего размера, вы можете увеличить размер шрифта, и вы можете делать это построчно. Например, первая строка (верхняя строка) может быть крупным текстом, а следующие строки — гораздо меньшим шрифтом.

Обратите внимание! На моем третьем фото самые верхние и самые нижние строки дисплея не видны на фотографии. Это проблема моей камеры, а не дисплея!

Интерфейс. Эти дисплеи используют последовательный протокол I2C (с адресом 0x3C), для которого требуется только два входа / выхода вашего микроконтроллера, Arduino или Raspberry Pi, оставляя вам много контактов свободными для других задач. I2C — это очень простой протокол, поддерживаемый несколькими библиотеками Arduino, которые просты в использовании и поставляются с ХОРОШИМИ примерами программ.Они очень удобны в использовании!

Графика. Это графические дисплеи, что означает, что вы можете использовать все 128 пикселей на 64 пикселя, чтобы делать все, что захотите, обеспечивая большой графический потенциал. Если вы будете заниматься серфингом, вы увидите, как люди делают удивительные вещи с этими дисплеями. Есть несколько очень хороших библиотек Arduino SSD1306, которые легко использовать с хорошими примерами рисования графики.

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

Энергопотребление. Энергопотребление этих устройств настолько низкое, что я не мог получить надежные показания с помощью своего испытательного оборудования. Моя лучшая оценка, подтвержденная результатами других людей, которые тестировали эти дисплеи, заключается в том, что они выдают около 20 мА при 3,3 вольт. Еще одна особенность этих дисплеев — они работают как от 5 В постоянного тока, так и от 3,3 В постоянного тока. Преобразователь уровня не требуется.В одном из своих приложений я запитал SSD1306 от выходного контакта Arduino — вот насколько низким было потребление тока.

Монтаж. Установить эти дисплеи довольно просто — просто вырежьте небольшое отверстие, которое немного меньше верхнего стекла дисплея в вашем проекте, и поместите дисплей за ним, используя четыре отверстия для крепления. Безель не нужен, и выглядит он очень привлекательно! Так думала даже моя жена … и она вообще думает, что большинство моих электронных проектов, ну, немного уродливые.(Но она удивительная женщина во многих других отношениях.)

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

Учебное пособие по графическому программированию для Arduino — Дисплей I2C LCD1602 «osoyoo.com

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

АППАРАТНОЕ ОБЕСПЕЧЕНИЕ

Плата Osoyoo UNO (полностью совместима с Arduino UNO rev.3) x 1
I2C LCD 1602 Дисплей x 1
Джемперы F / M
Кабель USB x 1
шт x 1

Интеграция ЖК-дисплея значительно упрощает интерактивность разрабатываемого вами проекта, позволяя пользователю напрямую считывать некоторые выходные параметры.Эти значения могут быть либо простым текстом, либо числовыми значениями, считываемыми датчиками, такими как температура или давление, или даже количеством циклов, которые выполняет Arduino.

Однако с этими дисплеями есть небольшая проблема. Когда они подключены к микроконтроллеру (например, Arduino), для этих дисплеев требуется практически много ПИН-кодов подключения, которые занимают практически все доступные вводы-выводы и оставляют у мультипроцессора несколько выходов для любых других устройств и датчиков.Эта проблема решена благодаря связи по шине I2C.

Дисплей LCD1602 имеет встроенный микрочип, который управляет этим типом связи, а затем вся входная и выходная информация ограничивается только двумя PIN-кодами (за исключением источника питания). I2C — это тип последовательной шины, разработанный Philips, который использует две двунаправленные линии, называемые SDA (последовательная линия данных) и SCL (последовательная линия синхронизации). Оба должны быть подключены через подтягивающие резисторы. Стандартные рабочие напряжения — 5 В и 3.3В.

Синий потенциометр на I2C LCD1602 (см. Рисунок ниже) используется для регулировки подсветки для лучшего отображения. А на плате есть перемычка, если вы уберете эту перемычку, подсветка всегда будет выключена.

Для использования других функций, пожалуйста, обратитесь к файлу «LiquidCrystal_I2C.h» в исходном коде библиотеки I2C LCD.

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

Osoyoo UNO	LCD1602
ЗЕМЛЯ	ЗЕМЛЯ
5В	VCC
A4	SDA
A5	SCL

Примечание:

Для Mega2560: соединения I2C находятся на SDA = 20 и SCL = 21.Итак, подключите их вместе с двумя выводами питания к клеммам 5V и GND .
Для Arduino Leonardo: подключите SDA к цифровому контакту 2, а SCL — к цифровому контакту 3 на вашем Arduino.

Из эскизов Fritzing вы можете посмотреть на соединения, которые нужно сделать более простым способом:

КОД ПРОГРАММЫ

После завершения вышеуказанных операций подключите плату Arduino к компьютеру с помощью кабеля USB. Зеленый светодиодный индикатор питания (с надписью PWR ) должен загореться.Откройте программу графического программирования Mixly и выполните следующие операции:

Щелкните блок Monitor и перетащите следующий код в пустую область, выберите 1602 LCD и установите адрес 0x27.

Добавьте ЖК-дисплей для этого эксперимента, в строке 1 напечатайте «Hello,», в строке 2 напечатайте «World!».

Теперь добавьте функцию задержки и очистку ЖК-дисплея,

Затем вы можете напечатать другие буквы, как показано ниже:

Щелкните Сохранить, после чего программирование завершено.Перед загрузкой выберите тип платы и последовательный порт. Для установки платы Uno просто выберите Arduino / Genuino Uno: если вы используете Mega2560, выберите Arduino / Genuino Mega или Mega2560.

Выберите последовательное устройство платы Arduino из меню COM . Скорее всего, это COM3 или выше ( COM1 и COM2 обычно зарезервированы для аппаратных последовательных портов). Чтобы узнать это, вы можете отключить плату Arduino и снова открыть меню; пропадающая запись должна быть платой Arduino.Снова подключите плату и выберите этот последовательный порт.

Затем загрузите код. Если загрузка не удалась, проверьте и исправьте код в соответствии с подсказками.

Наконец, статус изменится на «Загрузка успешна!».

Через несколько секунд после завершения загрузки вы должны увидеть, что ваш I2C LCD1602 отобразит статические символы: «Hello, World!», Затем ЖК-дисплей очистится, а затем «Hello, OSOYOO!» будет отображаться.

, сопряжение датчика пульсоксиметра MAX30100 с Arduino

Сопряжение датчика пульсоксиметра MAX30100 с Arduino

В этом проекте мы будем работать с датчиком пульсоксиметра MAX30100 I , совмещающим его с Arduino . Датчик MAX30100 может измерять кислорода в крови и пульс . Мы можем использовать любой дисплей, например ЖК-дисплей 16×2 , для просмотра значений SpO2 и ударов в минуту .Концентрация кислорода в крови, называемая SpO2, измеряется в процентах, а Сердцебиение / частота пульса измеряется в ударах в минуту.

MAX30100 — это датчик пульсоксиметрии и датчик сердечного ритма. Он сочетает в себе два светодиода , фотодетектор , оптимизированную оптику и малошумящую аналоговую обработку сигналов для обнаружения сигналов пульсовой оксиметрии и частоты сердечных сокращений. Вы можете использовать этот датчик с любым микроконтроллером, таким как Arduino , ESP8266 или ESP32 , и легко измерять параметры здоровья пациента.Этот дешевый датчик DIY Pulse Oximeter стоит всего около 5 долларов и может использоваться в нескольких приложениях, если вы новичок или энтузиаст электроники.

Вы можете выполнить некоторые из проектов, выполненных с использованием этого датчика:
1. Измерение кислорода в крови и пульса на OLED-дисплее
2. Пульсоксиметр IoT с использованием Blynk & ESP8266
3. Измерение SpO2 и BPM на Blynk с использованием ESP32
4. Система мониторинга здоровья пациентов на основе Интернета вещей

Спецификация

Ниже приведены компоненты, необходимые для взаимодействия датчика пульсоксиметра MAX30100 с Arduino.Вы можете приобрести все компоненты онлайн на Amazon. Название компонентов, а также ссылка на приобретение приведены ниже.

Как работает пульсоксиметр?

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

Маленькие лучи света проходят через кровь в пальце, измеряя количество кислорода. Он делает это путем измерения изменений в светопоглощении в оксигенированной или деоксигенированной крови .

MAX30100 Пульсоксиметр

Датчик представляет собой интегрированный датчик пульсоксиметрии и датчик пульса. Он сочетает в себе два светодиода, фотодетектор, оптимизированную оптику и малошумящую аналоговую обработку сигналов для обнаружения сигналов пульса и частоты сердечных сокращений.Он работает от источников питания 1,8 В и 3,3 В и может быть отключен с помощью программного обеспечения с незначительным током в режиме ожидания , что позволяет источнику питания всегда оставаться подключенным.

Характеристики

1. Потребляет очень мало энергии (работает от 1,8 В и 3,3 В)
2. Сверхнизкий ток отключения (0,7 мкА, тип.)
3. Возможность быстрого вывода данных
4. Тип интерфейса: I2C

Работа пульсоксиметра и датчика пульса MAX30100

В устройстве два светодиода , один излучает красный свет , другой излучает инфракрасный свет .Для измерения частоты пульса нужен только инфракрасный свет. И красный, и инфракрасный свет используются для измерения уровня кислорода в крови.

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

Оказывается, насыщенная кислородом кровь поглощает больше инфракрасного света и пропускает больше красного света, в то время как дезоксигенированная кровь поглощает красный свет и пропускает больше инфракрасного света.Это основная функция MAX30100: он считывает уровни поглощения для обоих источников света и сохраняет их в буфере, который может быть считан с помощью протокола связи I2C .

Сопряжение датчика пульсоксиметра MAX30100 с Arduino

Теперь давайте соединим датчик пульсоксиметра MAX30100 с Arduino и отобразим значение на последовательном мониторе. Принципиальная схема и подключение очень просты. Вы можете следовать тому же самому.

Подключите вывод Vin MAX30100 к Arduino 5V или 3.3V контакт, GND на GND. Подключите вывод I2C MAX30100, то есть SCL и SDA к A5 и A4 Arduino.

Исходный код / программа

Исходный код / программа для взаимодействия пульсоксиметра MAX30100 с Arduino написана на языке C для Arduino IDE. Этот код отобразит значение на последовательном мониторе. Скопируйте этот код и загрузите его на плату Arduino.

Но перед этим загрузил MAX30100 Library отсюда:
Arduino MAX30100 Library

140002

000

000 34

#include

#include «MAX30100_PulseOximeter.h»

#define REPORTING_PERIOD_MS 1000

PulseOximeter pox;

uint32_t tsLastReport = 0;

void onBeatDetected ()

{

Serial.println («Beat!»);

}

void setup ()

{

Serial.begin (115200);

Serial.print («Инициализация пульсоксиметра ..»);

// Инициализировать экземпляр PulseOximeter

// Сбои, как правило, связаны с неправильным подключением I2C, отсутствием источника питания

// или неправильным целевым чипом

if (! Pox.begin ()) {

Serial.println («НЕ ИСПОЛЬЗУЕТСЯ»);

для (;;);

} else {

Serial.println («УСПЕХ»);

}

pox.setIRLedCurrent (MAX30100_LED_CURR_7_6MA);

// Регистрируем обратный вызов для обнаружения биений

pox.setOnBeatDetectedCallback (onBeatDetected);

}

void loop ()

{

// Обязательно вызовите обновление как можно быстрее

pox.Обновить();

if (millis () — tsLastReport> REPORTING_PERIOD_MS) {

Serial.print («Частота пульса:»);

Serial.print (pox.getHeartRate ());

Serial.print («уд / мин / SpO2:»);

Последовательная печать (pox.getSpO2 ());

Serial.println («%»);

tsLastReport = millis ();

}

После загрузки кода откройте монитор последовательного порта, чтобы увидеть значения, как показано на изображении.Первоначально значение BPM и SpO2 отображается как неправильное значение, но вскоре вы можете увидеть правильное стабильное значение.

Отображение значений MAX30100 SpO2 и BPM на ЖК-дисплее

Теперь давайте воспользуемся ЖК-дисплеем 16X2 , чтобы увидеть значение ударов в минуту и SpO2 вместо последовательного монитора. Соберите схему согласно приведенной ниже схеме.

Подключите вывод Vin MAX30100 к Arduino 5V или 3.Контакт 3V, GND на GND. Подключите вывод I2C, SCL и SDA MAX30100 к A5 и A4 Arduino. Аналогичным образом подключите контакты 1, 5, 16 ЖК-дисплея к GND Arduino и 2, 15 к VCC. Аналогичным образом подключите контакты 4, 6, 11, 12, 13, 14 ЖК-дисплея к контактам 13, 12, 11, 10, 9, 8 Arduino. Используйте потенциометр 10K на контакте 3 ЖК-дисплея, чтобы отрегулировать контрастность ЖК-дисплея.

Исходный код / программа

140002

000

000 34

0002 47

00030002 47

0003

9 0002 64

#include

#include «MAX30100_PulseOximeter.h»

LiquidCrystal lcd (13, 12, 11, 10, 9, 8);

#define REPORTING_PERIOD_MS 1000

Пульсоксиметрическая оспа;

uint32_t tsLastReport = 0;

void onBeatDetected ()

{

Serial.println («Beat!»);

}

void setup ()

{

Serial.begin (115200);

Serial.print («Инициализация пульсоксиметра.. «);

lcd.begin (16,2);

lcd.print (» Инициализация … «);

delay (3000);

lcd.clear ();

// Инициализируйте PulseOximeter instance

// Сбои обычно возникают из-за неправильной проводки I2C, отсутствия источника питания

// или неправильного целевого чипа

if (! Pox.begin ()) {

Serial.println («FAILED»);

для (;;);

} else {

Serial.println («УСПЕХ»);

}

pox.setIRLedCurrent (MAX30100_LED_CURR_7_6MA);

// Регистрируем обратный вызов для обнаружения биений

pox.setOnBeatDetectedCallback (onBeatDetected);

}

void loop ()

{

// Обязательно вызовите update как можно быстрее

pox.update ();

if (millis () — tsLastReport> REPORTING_PERIOD_MS) {

Serial.print («Частота пульса:»);

Серийный.печать (pox.getHeartRate ());

Serial.print («уд / мин / SpO2:»);

Последовательная печать (pox.getSpO2 ());

Serial.println («%»);

lcd.clear ();

lcd.setCursor (0,0);

lcd.print («BPM:»);

lcd.print (pox.getHeartRate ());

lcd.setCursor (0,1);

lcd.print («SpO2:»);

lcd.print (pox.getSpO2 ());

ЖК.Распечатать(«%»);

tsLastReport = millis ();

}

После загрузки кода вы можете приложить палец к датчику MAX30100, и на ЖК-дисплее начнется отображение процентного содержания кислорода и значения ударов в минуту.

MAX30100 Не работает Поиск и устранение неисправностей

Если вы приобрели модуль MAX30100, показанный ниже, он может не работать, поскольку имеет серьезную конструктивную проблему. В микросхеме MAX30100 для VDD используется 1,8 В, и этот конкретный модуль использует два регулятора для достижения этого напряжения.

Ничего страшного в этом нет. Однако, если вы присмотритесь, контакты SCL и SDA подтянуты через резисторы 4,7 кОм до 1,8 В! Это означает, что он не будет работать с микроконтроллерами с более высокими логическими уровнями.

Есть два способа исправить эту проблему и заставить MAX30100 РАБОТАТЬ.

1-й метод

Решение состоит в том, чтобы удалить резисторы с платы (обведены кружком на изображении ниже) и вместо этого подключить внешние резисторы 4,7 кОм к выводам SDA, SCL и INT.

После удаления всех резисторов 4,7 кОм подключите выводы INT, SDA, SCL к внешнему подтягивающему резистору 4,7 кОм.

2-й метод

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

Демонстрация видео и объяснение

Измерение кислорода в крови и пульса с помощью пульсоксиметра MAX30100 / 02 и Arduino

Взаимодействие OLED 128×64 I2C с Arduino Uno »DIY Usthad

В этом руководстве мы научимся взаимодействовать с Arduino UNO и монохромным дисплеем OLED 128 × 64 I2C.

Требуемые навыки

Basic: это руководство хорошо объяснено для начинающих.

Схема

Соедините контакты OLED со следующими контактами Arduino UNO, как показано ниже.

Ардуино UNO	Дисплей OLED I2C
5в	VCC
GND	GND
SDA / A4	SDA
SCL / A5	SCL

Установить необходимые библиотеки

Либо вы можете загрузить библиотеки с Github и добавить ZIP-файл в Arduino IDE, используя команду add.zip-библиотека вариант.

Или вы можете установить библиотеки прямо из Arduino IDE из Manage Libraries. Для установки выполните следующие действия.

эскиз -> включить библиотеку -> управлять библиотеками

Открыть библиотеку управления из эскиза -> включить библиотеку -> управлять библиотеками

установить библиотеку adafruit ssd1306

Затем найдите AdafruitSSD1306 и нажмите кнопку установки.

установить библиотеку adafruit gfx

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

Adafruit Пример кода

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

Откройте пример программы из Файл -> Примеры -> Adafruit SSD1306 -> ssd1306_128x64_i2c,

т.к. мы используем OLED-дисплей с интерфейсом I2C с размером экрана 128 × 64.

Теперь загрузим код

Перейдите в меню инструментов -> Платы выберите Arduino UNO, затем в Порт выберите порт, к которому подключен Arduino.

Видео

I2C Arduino Uno Tutorial: I2C Tutorial для начинающих | Arrow.com

Если ваше приложение требует обмена данными между отдельными интегральными схемами, решение может быть использовано с помощью технологии I²C. С момента своего появления в 1982 году I2C позволяет работать с несколькими узлами, используя только два провода для передачи сигналов.Эта технология, также известная как IIC или I2C, или, как немного другая версия, двухпроводной интерфейс (TWI), все еще используется сегодня, а с 2006 года пользователи могут ее реализовать. Вы можете найти I²C в различных технологиях, включая периферийные устройства, которые работают с различными доступными платами Arduino .

Проводка I2C: настройка физической проводки

Изображение: Джереми С. Кук

Давайте начнем с основ того, что вам понадобится для запуска модуля I²C.В этом руководстве мы предполагаем, что вы используете Arduino Uno, хотя вы можете использовать любую Arduino или даже другую вычислительную систему. Дополнительную информацию можно найти в документации библиотеки Arduino Wire , фрагменте кода, который обычно связан с технологией I²C. Настройте свою доску следующим образом:

SDA (последовательная линия данных): A4
SCL (Последовательная линия синхронизации): A5
Vcc: + 5 В или потенциально + 3,3 В в зависимости от модуля
Земля: Земля
Прерывание: зависит от модуля и программирования

Вам также необходимо подключить SDA и SCL к положительному напряжению через подтягивающий резистор.Мы используем для этой настройки значение 4,7 кОм, что является стандартным, но не обязательным. Некоторые платы даже имеют встроенные приспособления для этих резисторов. Обратите внимание: вам понадобится только один резистор для каждой линии, даже если вы соединили в цепочку несколько модулей.

Модули

I²C содержат значение по умолчанию для своего адреса, но для их настройки вам потребуется использовать перемычки или подключить определенные контактные площадки для пайки. Если вы не уверены в адресе своего устройства, и особенно если собираетесь использовать в своем проекте только одно устройство I²C, используйте программу под названием Arduino I2C Scanner , чтобы увидеть адрес каждого подключенного устройства.

Пример Arduino I2C

Изображение: Джереми С. Кук

Технология

I²C может упростить и улучшить многие из ваших приложений; мы продемонстрируем, как настроить кодировщик I²C, а также небольшой OLED-дисплей . Мы использовали интерфейс I²C кодировщика , который поставляется в виде небольшой платы с компонентами I²C. Этот интерфейс не включает сам кодировщик.

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

2. Эта распиновка одинакова для большинства модулей, но вам нужно будет подключить пятый провод, обозначенный как «INT» для прерывания, к A2. Этот провод не идет к контакту прерывания Arduino; вместо этого он предлагает мастеру Arduino принять сигнал от подчиненного модуля кодировщика.

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

В зависимости от вашего устройства вам может потребоваться изменить адрес, который находится в диапазоне от 0 до 127 в шестнадцатеричном формате, что выражается как от 0x00 до 0x7F.Вы также можете выбрать другую строку для комментария или раскомментирования в зависимости от того, какой тип кодировщика вы используете.

Хотя формат I²C остается неизменным физически, универсальность этой шины означает, что существует довольно много вариантов того, как реализовать его на стороне программного обеспечения. Для поиска правильных конфигураций может потребоваться некоторая калибровка, но потенциальная экономия на вводе-выводе и накладных расходах процессора очень окупает затраченные усилия.

I²C Выход

Пренебрегая тем фактом, что кодировщик I²C, который мы использовали здесь, имеет свои собственные возможности вывода — в основном в виде добавленного GPIO — что, если вы хотите использовать I²C для получения визуальной обратной связи? Один из способов добиться такой обратной связи — использовать доступный OLED-дисплей 128×16 пикселей .

Подключаем эти устройства так же, как энкодер. Однако в этой настройке нет контакта «прерывание», поскольку крошечный монитор является полностью пассивным устройством, реагирующим на сигналы от Arduino, а не наоборот. Мы использовали аналогичный набор резисторов между выводами SCL и SDA и выводом VCC, но вы можете найти примеры, в которых резисторы не используются.

Изображение. Вот незначительные изменения кода, которые вам потребуются для того, чтобы OLED-экран заработал.Джереми С. Кук

Для запуска устройства вам понадобится Adafruit SSD1306, а также библиотеки Adafruit GFX, которые доступны через менеджер библиотек Arduino IDE. Вот как выглядит процесс:

1. Загрузите пример программы ssd1306_128x64_i2c, чтобы запустить устройство.

2. Как и в случае с поворотным энкодером, вам потребуется изменить несколько компонентов. Сначала измените значение высоты в библиотеке Adafruit_SSD1306.h на 128×64, раскомментировав нужную строку с помощью расширенного текстового редактора, такого как Atom.Для моего дисплея мне пришлось изменить адрес C I ² на 0x3C с 0x3D, чтобы он соответствовал его значению I²C. Обычно мы можем найти подходящую стоимость для этого типа устройства, используя сканер I ² C.

3. Затем загрузите пример программы на плату Arduino.

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

One Wire I2C: реализация двойной роли

Изображение: Джереми С. Кук

Кодировщик обеспечивает числовой ввод, а OLED-экран предоставляет метод вывода, так почему бы не объединить два? Мы написали базовый код для кодировщика, который отображал значение в прокручиваемом тексте, включенном в демонстрацию. Это приложение дает пользователям визуальную индикацию того, как далеко поворачивается ручка. Более того, мы можем использовать этот же метод для управления несколькими устройствами в режиме ввода или вывода по одним и тем же двум линиям.Кодер может передавать на дисплей выводы питания, заземления, SCL и SDA, что означает, что Arduino не требует дополнительных выводов.

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

Другой пример использования компонента I ² C с Arduino можно найти в этой статье о работе с акселерометром MPU-6050 .

Основы протокола связи I2C

До сих пор мы говорили об основах связи SPI и UART, так что теперь давайте перейдем к последнему протоколу этой серии, межинтегральной схеме или I2C.

Вероятно, вы обнаружите, что используете I2C, если когда-нибудь будете создавать проекты, в которых используются OLED-дисплеи, датчики атмосферного давления или модули гироскопа / акселерометра.

Введение в связь I2C

I2C сочетает в себе лучшие возможности SPI и UART. С помощью I2C вы можете подключить несколько подчиненных устройств к одному мастеру (например, SPI), и у вас может быть несколько мастеров, управляющих одним или несколькими подчиненными. Это действительно полезно, если вы хотите иметь более одного микроконтроллера, записывающего данные на одну карту памяти или отображающего текст на одном ЖК-дисплее.

Как и связь UART, I2C использует только два провода для передачи данных между устройствами:

SDA (последовательные данные) — линия для ведущего и ведомого устройства для отправки и получения данных.

SCL (Serial Clock) — Линия, по которой передается тактовый сигнал.

I2C — это протокол последовательной связи, поэтому данные передаются бит за битом по одному проводу (линия SDA).

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

Как работает I2C

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

Условие запуска: Линия SDA переключается с высокого уровня напряжения на низкий уровень перед тем, как линия SCL переключается с высокого на низкий.

Условие остановки: Линия SDA переключается с низкого уровня напряжения на высокий уровень после линия SCL переключается с низкого уровня на высокий.

Адресный кадр: 7- или 10-битная последовательность, уникальная для каждого ведомого устройства, которая идентифицирует ведомое устройство, когда ведущее устройство хочет с ним поговорить.

Бит чтения / записи: Один бит, определяющий, отправляет ли ведущее устройство данные ведомому (низкий уровень напряжения) или запрашивает данные от него (высокий уровень напряжения).

Бит ACK / NACK: За каждым кадром в сообщении следует бит подтверждения / отсутствия подтверждения. Если адресный кадр или кадр данных были успешно получены, от принимающего устройства отправителю возвращается бит ACK.

Адрес

I2C не имеет строк выбора подчиненного устройства, таких как SPI, поэтому ему нужен другой способ сообщить подчиненному, что данные отправляются ему, а не другому подчиненному устройству. Он делает это с помощью адреса по адресу . Адресный кадр всегда является первым кадром после стартового бита в новом сообщении.

Мастер отправляет адрес подчиненного устройства, с которым он хочет связаться, каждому подчиненному устройству, подключенному к нему. Затем каждое ведомое устройство сравнивает адрес, отправленный ведущим, со своим собственным адресом. Если адрес совпадает, он отправляет бит ACK низкого напряжения обратно мастеру. Если адрес не совпадает, ведомое устройство ничего не делает, и линия SDA остается на высоком уровне.

Бит чтения / записи

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

Фрейм данных

После того, как ведущее устройство обнаруживает бит ACK от ведомого, первый кадр данных готов к отправке.

Кадр данных всегда имеет длину 8 бит и отправляется первым со старшим битом. За каждым фреймом данных сразу же следует бит ACK / NACK, чтобы убедиться, что фрейм был принят успешно.Бит ACK должен быть получен либо ведущим, либо ведомым (в зависимости от того, кто отправляет данные), прежде чем можно будет отправить следующий кадр данных.

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

Этапы передачи данных I2C

1. Ведущее устройство отправляет условие запуска каждому подключенному ведомому устройству, переключая линию SDA с высокого уровня напряжения на низкий уровень перед тем, как переключает линию SCL с высокого на низкий:

2.Мастер отправляет каждому подчиненному 7- или 10-битный адрес подчиненного устройства, с которым он хочет связаться, вместе с битом чтения / записи:

3. Каждое ведомое устройство сравнивает адрес, отправленный ведущим, со своим собственным адресом. Если адрес совпадает, ведомое устройство возвращает бит ACK, подтягивая линию SDA к низкому уровню на один бит. Если адрес от ведущего устройства не совпадает с собственным адресом ведомого, ведомый оставляет линию SDA на высоком уровне.

4. Мастер отправляет или получает фрейм данных:

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

6. Чтобы остановить передачу данных, ведущее устройство отправляет условие остановки ведомому, переключая SCL на высокий уровень перед переключением на высокий уровень SDA:

Один мастер с несколькими подчиненными

Поскольку I2C использует адресацию, несколько ведомых устройств могут управляться с одного ведущего устройства. При 7-битном адресе доступен 128 (2 ⁷) уникальный адрес.Использование 10-битных адресов встречается редко, но обеспечивает 1024 (2 ¹⁰) уникальных адреса. Чтобы подключить несколько подчиненных устройств к одному мастеру, подключите их так: подтягивающие резисторы 4,7 кОм соединяют линии SDA и SCL с Vcc:

Несколько мастеров с несколькими подчиненными

Несколько мастеров могут быть подключены к одному или нескольким подчиненным. Проблема с несколькими мастерами в одной системе возникает, когда два мастера пытаются отправить или получить данные одновременно по линии SDA.Чтобы решить эту проблему, каждому мастеру необходимо определить, высокий или низкий уровень линии SDA перед передачей сообщения. Если на линии SDA низкий уровень, это означает, что другой ведущий контролирует шину, и ведущий должен дождаться отправки сообщения. Если линия SDA высокий, то сообщение безопасно. Чтобы подключить несколько мастеров к нескольким подчиненным, используйте следующую схему с подтягивающими резисторами 4,7 кОм, соединяющими линии SDA и SCL с Vcc:

Преимущества и недостатки I2C

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

Преимущества

Использует только два провода
Поддерживает несколько мастеров и несколько ведомых устройств
Бит ACK / NACK подтверждает, что каждый кадр успешно передан
Оборудование менее сложное, чем с UART
Хорошо известный и широко используемый протокол

Недостатки

Более медленная скорость передачи данных, чем у SPI
Размер кадра данных ограничен 8 битами
Более сложное оборудование, необходимое для реализации, чем SPI

Спасибо за чтение! Надеюсь, вы кое-что узнали из этой серии статей о протоколах электронной связи.