Ws2815 arduino подключение

Инструкция по подключению Arduino к адресной светодиодной ленте

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

Для начала необходимо разобраться с потреблением светодиодной ленты. Дело в том, что каждый светодиод в пикселе потребляет до 20 мА, в зависимости от яркости его свечения. Напомню, что яркость свечения задаем мы сами из программы. Итого получается, что каждый пиксель может потреблять до 60 мА. Это довольно много, если учитывать, что мы можем использовать несколько метров ленты. Но в рамках данной статьи я буду экспериментировать с отрезком на 5 пикселей. И по этой причине запитаю адресную ленту прямо от Arduino Nano . Хотя я бы сам не рекомендовал так делать, лучше всего ставить отдельный блок питания и подключить ленту к нему, а с МК реализовать только управление.

Как мы помним из прошлых статей, управление будет осуществлено любым из цифровых выходов с D 2 по D 13. В данном случае я решил использовать D 5 (просто для примера, Вы можете использовать любой). Итак, подключаем ленту к Arduino Nano . GND к GND , +5 V к +5 V и D — input к D 5 на плате Nano . Я не стал ничего придумывать и просто припаял. Визуально выглядит адресная лента подключенная к Ардуино:

А вот схема подключения адресной ленты к Arduino:

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

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

Пишем программу для управления адресной светодиодной лентой через Arduino. Установка библиотеки

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

Для начала давайте откроем IDE Arduino . Это программа, которую мы установили в одной из прошлых статей.

Получилось? Отлично! Далее нам необходимо установить библиотеку. Это нужно, чтобы управлять адресной лентой. Дело в том, что лента принимает определенный набор команд, но нам, как молодым разработчикам, пока не интересно, что это за команды и как они устроены. Мы просто хотим управлять цветами. И библиотека управления адресной лентой поможет нам сделать это максимально просто и быстро. Мы будем сообщать программе, где какой цвет хотим видеть, а программа, с помощью библиотеки, будет формировать наборы команд, понятные для микросхем адресной ленты. На самом деле все достаточно просто и очевидно, нужно только привыкнуть. Поэтому нажимаем «Скетч» -> «Подключить библиотеку» — > «Управлять библиотеками».

После этого появится окно «Менеджер библиотек». Кстати, данному окну нужно немного времени чтобы прогрузиться, поэтому пару секунд оно будет не активным, нужно подождать.

На данный момент мы будем использовать библиотеку « Adafruit NeoPixel ». Проще всего будет воспользоваться поиском. Как видно, в списке есть похожие название, нужно быть внимательным и не перепутать.

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

Пишем программу для управления лентой через Ардуино

И теперь мы приступаем к следующему этапу — написанию программы. Начнем с чего-то простого и потом будем постепенно совершенствовать. Наша первая программа будет выглядеть следующим образом:

#define LED_COUNT 5

#define LED_PIN 5

Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

strip.begin(); //Инициализируем ленту.

strip.setPixelColor(i, strip.Color(255, 0, 0)); // Красный цвет.

strip.setPixelColor(i, strip.Color(0, 0, 0)); // null

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

Начнем с первой строчки. Тут мы объявляем библиотеку. Дело в том, что перед этим мы только ее скачали, а чтобы использовать в программе, необходимо ее объявить. Для этого используется директива # include <>. Где в скобках указано имя файла, который будет использоваться при компиляции, как часть кода. В нашем случае это название библиотеки. Кстати да, библиотека – это файл с программой.

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

Обратите внимание: речь идет именно о количестве пикселей, то есть чипов в ленте, а не о количестве светодиодов. В некоторых адресных лентах, например с чипом ws2811 и ws2818 управление происходит кратно 3 диодам, поэтому лента с 60 диодами на метр будет управляться всего 20 пикселями. Если у вас адресная лента ws2812b, ws2813 или ws2815, то управление происходит кратно одному диоду, то есть количество пикселей = количество светодиодов.

Идем далее. Директива # define определяет идентификатор и последовательность символов, которой будет замещаться данный идентификатор при его обнаружении в коде. Давайте разберем вторую строку более подробно «#define LED_COUNT 5». «LED_COUNT» — это идентификатор, которому соответствует символ «5». Это позволит нам в теле программы (везде, где нужно) написать «5», писать «LED_COUNT». Возможно, это звучит немного непотяно, но подумайте вот о чем: нам пришло в голову изменить кол-во пикселей в ленте и тогда нам придется во всем коде менять их кол-во. Но благодаря # define , мы имеем возможность поменять всего лишь последовательность символов в идентификаторе. Понятное дело, в нашей программе возможно заменить все значения, потому что тут всего 2-а десятка строк. Но бывают и очень большие программы, где действия по замене потребуют огромного количества времени и терпения.

В пятой строке мы объявляем экземпляр класса Adafruit_NeoPixel и передаем его конструктору значения о длине ленты, выводе управления и типу адресной ленты. В данной статье мы не будем разбирать само понятие классов, поэтому предлагаю просто принять данную строчку как должное, где в скобках мы передаем необходимые параметры. Скажу только одно: тут мы создали объект под именем « strip ». И этот объект полностью отвечает за работу подключенной ленты.

В теле функции setup () мы сообщаем компилятору, что данный объект « strip » у нас будет использован. По сути, эту команду инициализации пока тоже нужно принять как необходимый минимум.

А дальше у нас уже идет самое интересное — основная часть программы, в которой и происходит волшебство, она находится в теле функции loop (). Но перед этим необходимо ввести новое понятие – цикл.

Цикл — это определенный блок программы, выполняющийся по кругу. Даже сама функция loop () является циклом. Циклы бывают конечными и бесконечными и у циклов так же, как и у функций, есть тело, где написаны повторяющиеся команды. В данной программе мы использовали цикл – for . Если данный цикл описан правильно, то он, как правило, конечен. Цикл for имеет 3 параметра «for(int i = 0; i Первый параметр задает начальное значение для переменной i . Кстати, в данном случае переменная i инициализируется при начале работы цикла и забывается при окончании работы цикла. Второй параметр – это условие, при котором цикл продолжает выполняться. В нашем случае цикл выполняется до тех пор, пока i меньше 5. И третий параметр прибавляет единицу к i , при каждом повторе цикла. Сейчас ограничимся этим коротким объяснением. В дальнейшем у меня выйдет короткая статья, посвящённая программированию.

Итак, вернемся к программе. С 13-ой по 17-ую строку у нас расположен цикл, цикл на 5 повторений, где i меняется от 0 до 4 включительно.

В 14-ой строке мы вызываем метод setPixel , объекта strip и передаем ему два параметра. Где i это номер пикселя на адресной ленте, а « s trip.Color(255, 0, 0)» его цвет. Про то, как задается цвет по системе RGB мы уже говорили ранее. Скажу только очевидную вещь, «255, 0, 0» — это максимально красный цвет.

Получается, когда мы объявили объект strip и передали ему, что в нашей адресной ленте будет 5 пикселей, то в памяти было зарезервировано 5 ячеек, предназначенные для хранения цвета. И теперь в данном цикле мы их заполняем.

В 15-ой строке расположена команда, которая выводит на ленту цвета из памяти в МК (микроконтроллер). То есть последовательность такая: сначала пишем цвета в память, потом разом выводим их на адресную ленту. Изначально пока мы еще не успели заполнить память, там хранятся нулевые цвета «0, 0, 0».

И в 16-ой строке у нас стоит задержка в 300 млс.

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

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

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

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

Источник

Лёгкая библиотека для адресной ленты v3.5

ОБНОВЛЕНИЯ

v3.3 Исправлен критический баг с влиянием на другие пины

  • Переработан ASM вывод, меньше весит, легче адаптируется под другие частоты / тайминги
  • Добавлена поддержка LGT8F328P с частотой 32/16/8 MHz
  • Переработан поллинг millis()/micros() – прямой вызов прерывания TIMER0_OVF, убран лишний код

v3.5 Исправлена ошибка компиляции в некоторых угодных компилятору случаях

ТЕОРИЯ

Мы с вами уже обсуждали адресные светодиодные ленты, есть гайд по особенностям подключения и сравнение библиотек. Что объединяет все библиотеки для управления адресной светодиодной лентой? Правильно, проблемы с нехваткой памяти, потому что один светодиод требует 3 байта оперативной памяти, по байту на каждый базовый цвет: красный, зелёный и синий. Протокол передачи данных на ленту состоит из последовательных передач байта каждого цвета, примерно так: R1, G1, B1, R2, G2, B2… Rn, Gn, Bn. Именно поэтому микроконтроллер хранит в памяти байт каждого цвета каждого светодиода в ленте. Для одного светодиода это выглядит так: RRRRRRRR GGGGGGGG BBBBBBBB – по 8 бит на каждый цвет. А что если попробовать “сжать” цвет? Мы попробовали!

БИБЛИОТЕКА

microLED v3.5

microLED – ультра-лёгкая библиотека для работы с адресной лентой/матрицей

  • Основная фишка: сжатие цвета, код занимает в разы меньше места в SRAM по сравнению с аналогами (FastLED, NeoPixel и др.)
    • Использование 8 битного цвета занимает в 3 раза меньше SRAM чем у других библиотек
    • Использование 16 битного цвета занимает в 2/3 раза меньше SRAM чем у других библиотек
  • Работа с цветом:
    • RGB
    • HSV
    • HEX цвета
    • “Цветовое колесо”
    • Температура цвета
    • 17 встроенных цветов
    • Градиенты, фейды и другие инструменты
  • Возможность чтения сжатого цвета
  • Ограничение тока (автокоррекция макс. яркости)
  • Быстрейшая реализация протокола общения с лентой
  • Поддержка работы с адресными матрицами (см. пример)
  • Поддержка чипов: WS2811, WS2812, WS2813, WS2815, WS2818, WS6812, APA102 (программно и SPI)
  • Возможность работать без буфера (не занимая память в RAM)
  • Поддержка всех AVR в том числе мелких аттини
  • И многое другое!

Поддерживаемые платформы: ТОЛЬКО ДЛЯ АРХИТЕКТУРЫ AVR. тестировалось только на ATmega328 (Nano, UNO, Mini) и ATtiny85/ATtiny13. Должны поддерживаться и остальные МК этого поколения, тактовая частота только 8 и 16 МГц, а также 9.6 МГц для АТтини13.

УСТАНОВКА

  • Библиотеку можно найти и установить через менеджер библиотек по названию microLED в:
    • Arduino IDE (Инструменты/Управлять библиотеками)
    • Arduino IDE v2 (вкладка “Library Manager”)
    • PlatformIO (PIO Home, вкладка “Libraries”)
  • Про ручную установку читай здесь

ДОКУМЕНТАЦИЯ

ОСОБЕННОСТИ

Данная библиотека нужна для проектов с лентой, в которых критичен объём занимаемой оперативной памяти: его можно уменьшить в 1.5 и 3 раза по сравнению с обычными библиотеками, а также вообще отказаться от динамического буфера и управлять лентой любой длины даже с ATtiny!! Библиотека написана очень просто, используемые в ней алгоритмы и решения очень прозрачны и могут кому-нибудь пригодиться. Единственный минус: инструменты для генерации и изменения цвета работают медленнее, чем в FastLED, поэтому для быстрых красивых эффектов на большой ленте/матрице придётся подключать фастлед для быстрой математики.

ПОДДЕРЖКА FASTLED (NEW!)

В версии 3.1 появилась полноценная поддержка совместной работы с FastLED для быстрого вычисления эффектов. Это позволяет выводить всякие шумы по палитрам даже на АТтини!! Для этого подключаем в скетч #include (смотри примеры), саму FastLED подключать не нужно, она подключится автоматически. У нас появится функция CRGBtoData() , которая переводит тип данных фастледа в микролед (конвертирует CRGB в mData при любой глубине цвета). В качестве примера работы с палитрой можно глянуть пример FIRE_with_FastLED.

ЦВЕТОВАЯ ГЛУБИНА

Цветовая глубина задаёт количество байт, которые занимает цвет одного светодиода и может быть от 1, 2 и 3 байта (8, 16 и 24 бита на один светодиод соответственно). Все остальные библиотеки используют 24-битную глубину цвета, в microLED её можно уменьшить для экономии памяти. При уменьшении цветовой глубины пропорционально уменьшается вес ленты в оперативной памяти, но в то же время ухудшается цвет: на эффектах с плавными переходами цвета будут заметны границы между оттенками. Настройка цветовой глубины задаёт работу всей библиотеки и делается при помощи дефайна COLOR_DEBTH до подключения библиотеки:

По умолчанию (если не указывать дефайн) глубина настроена на 24 бита (COLOR DEBTH 3). Понижать глубину рекомендуется только в целях экономии памяти.

ГАММА КОРРЕКЦИЯ

Ещё одна настройка, которая делается дефайном и влияет на всю библиотеку сразу. Гамма коррекция позволяет получать более естественные цвета и их смеси, а также более приятные глазу переходы яркости и реализована 4мя способами:

  • #define CRT_OFF — коррекция отключена для экономии памяти и ускорения вычислений.
  • #define CRT_PGM — коррекция по таблице. Добавляет 256 байт во Flash память, но работает быстрее и красивее всех остальных.
  • #define CRT_SQUARE — квадратная коррекция. Занимает мало памяти, выполняется гораздо дольше таблицы (около 7 мкс).
  • #define CRT_CUBIC — кубическая коррекция. Выглядит приятнее квадратной, но выполняется ещё дольше.

По умолчанию включена коррекция по таблице. Остальные режимы — для продвинутого пользователя и экспериментов.

КАК РАБОТАЕТ БИБЛИОТЕКА?

Режим буфера

При инициализации указываем длину ленты, внутри библиотеки будет создан буфер типа mData , который занимает 1, 2 или 3 байта в зависимости от выбранной цветовой глубины и олицетворяет цвет в формате RGB. С данным массивом можно работать как с обычным массивом и присваивать его элементам цвет в формате mData (например, strip.leds[5] = mRed ). Само собой, массив занимает место в оперативной памяти микроконтроллера пропорционально длине ленты. Забив буфер цветами, можно вызвать strip.show() и лента обновится с максимально возможной скоростью.

Режим потока

В этом режиме буфер не создаётся (количество светодиодов указываем 0), оперативная память не занимается, а мы генерируем цвет пикселей «на лету». Для начала передачи нужно вызвать .begin() , для передачи цвета — .send(mData цвет) нужное количество раз и завершить вывод вызовом .end() .

Тут есть некоторые ограничения: между вызовами send() должно пройти не более 50-300 мкс (в зависимости от модели ленты), иначе вывод сбросится. Для экономии времени можно заранее посчитать цвет перед выводом, например зальём всю ленту:

ИНИЦИАЛИЗАЦИЯ ЛЕНТЫ

В библиотеке версии 3 и выше лента объявляется через шаблон: microLED объект:

  • amount — количество светодиодов в ленте. Для работы в режиме потока можно указать 0 , так как длина ленты фактически ничем не ограничена.
  • pin — пин, к которому подключен дата-вход ленты (D, Din, DI).
  • clock — пин, к которому подключен тактовый-вход ленты (C, CLK). Этот пин подключается только для SPI лент, например APA102.
    • Для работы с лентами серии WSxxxx нужно указать вместо этого пина параметр MLED_NO_CLOCK или минус 1 , т.е. -1
  • chip — модель ленты (светодиодов), в библиотеке поддерживаются LED_WS2811 , LED_WS2812 , LED_WS2813 , LED_WS2815 , LED_WS2818 , LED_WS6812 , APA102 , APA102_SPI . Выбор модели ленты задаёт скорость протокола (она у них разная) и настройки тока потребления для режимов ограничения (о них читай дальше).
  • order — порядок цветов в ленте. В идеальном мире порядок цветов должен зависеть от модели чипа и эта настройка должна быть встроена в выбор чипа, но китайцы торгуют лентами, которые по протоколу совпадают с одним чипом, но имеют другой порядок цветов. Таким образом библиотека поддерживает больше типов лент, чем написано выше, но нужно угадать с выбором «клона» и порядок цветов. Порядок: ORDER_RGB , ORDER_RBG , ORDER_BRG , ORDER_BGR , ORDER_GRB , ORDER_GBR .

Оригинальные ленты на поддерживаемых библиотекой чипах имеют такой порядок цветов, также это готовая строка инициализации:

Можно вставить прямо в свой код =) Оставшиеся две настройки не являются обязательными (можно не указывать):

  • cli — выбор настроек запрета прерываний для повышения надёжности вывода данных на ленту:
    • CLI_OFF — прерывания не отключаются (возможны сбои в работе ленты даже от прерываний системного таймера)
    • CLI_LOW — прерывания отключаются на время передачи одного цвета
    • CLI_AVER — прерывания отключаются на время передачи светодиода (3 цвета)
    • CLI_HIGH — прерывания отключаются на время передачи данных на всю ленту
  • millis — при отключении прерываний в режиме среднего и высокого приоритета ( CLI_AVER и CLI_HIGH ) неизбежно будут чуть отставать функции времени millis() и micros(). В библиотеке встроено обслуживание функций времени, для активации передаём SAVE_MILLIS 6-ым аргументом при инициализации: microLED strip ;

ОСОБЕННОСТИ 2Х ПИНОВЫХ ЛЕНТ (NEW!)

Существует два вида лент, имеющих 2 пина для управления (помимо питания):

  • Ленты моделей WS2813, WS2815, WS2818 и их копии с буквами SK и такими же цифрами. У этих лент подключается только один пин из двух, тот который DI. Пин BI (B) не подключается. При инициализации указывается только DI пин, второй пишем -1 или «заглушку» MLED_NO_CLOCK .
  • Ленты моделей APA102 (она же SK9822) требуют подключения именно двух своих пинов, один из которых Data (D, DI, DAT), а второй — Clock (C, CLK, SCK). При инициализации указываем оба.

SPI ЛЕНТЫ (NEW!)

В библиотеке версии 3.1 добавлена поддержка SPI лент, в том числе аппаратная (на базе стандартной библиотеки SPI.h). Рассмотрим куски примеров.

При выборе LED_APA102 ленту можно подключить на любые два пина и указать их при инициализации. Всё

При выборе LED_APA102_SPI лента подключается к выводам аппаратной шины SPI микроконтроллера:

  • Data пин на MOSI (D11 на Arduino Nano)
  • Clock пин на SCK (D13 на Arduino Nano)

Что это даёт? Аппаратный SPI позволяет выводить данные на ленту чуть ли не в 10 раз быстрее, чем программный способ! В коде должно быть:

Пины в этом случае не указываются! Ставим заглушку или -1. Это всё.

ГЕНЕРАЦИЯ ЦВЕТА

Для работы с цветом в библиотеке есть несколько инструментов, возвращающих тип данных mData для отправки на ленту или в буфер. mData — тип данных, который олицетворяет цвет светодиода в формате RGB. В зависимости от выбранной цветовой глубины является:

  • 8 бит — uint8_t
  • 16 бит — uint16_t
  • 24 бита — struct

Собственно инструменты и функции:

  • mRGB(r, g, b) — итоговый цвет будет замешан из красного, зелёного и синего, все параметры задаются в диапазоне 0-255
  • mHSV(h, s, v) — цвет из пространства hsv: цвет, насыщенность, яркость. Все параметры задаются в диапазоне 0-255. Цвет в диапазоне 0-255 совершает круг от красного к зелёному, от зелёного к синему и от синего снова к красному. Функция «тяжёлая», поэтому для генерирования «радуги» рекомендуется использовать mWheel() и mWheel8()
  • mHSVfast(h, s, v) — то же самое, но выполняется быстрее и даёт менее приятные глазу цветовые переходы
  • mWheel(val) — принимает значение от 0 до 1530 и возвращает цвет из цветового круга, как и hsv. Выполняется очень быстро
  • mWheel(val, bright) — то же самое, но с яркостью (0-255)
  • mWheel8(val) — то же самое что предыдущий, но принимает 0-255 и делает цвет постоянной яркости.
  • mWheel8(val, bright) — то же самое, но с яркостью (0-255)
  • mHEX(val) — принимает цвет в формате RGB888 (обычный web-формат). Например 0xFF0000 это красный
  • mKelvin(temp) — выдает цвет, соответствующий цветовой температуре temp в кельвинах
  • 16 предустановленных цветов: mWhite, mSilver, mGray, mBlack, mRed, mMaroon, mOrange, mYellow, mOlive, mLime, mGreen, mAqua, mTeal, mBlue, mNavy, mMagenta, mPurple
  • getBlend(val, max, color1, color2) — выдает цвет в указанном месте градиента двух цветов: val — искомая точка (от 0 до max), max — размер градиента, color1 и color2 — цвета, соответствующие 0 и max позиции градиента. Например getBlend(30, 100, mRed, mBlack) вернёт красный, смешанный с черным на 30/100, то есть чуть темнее красного.
  • getFade(mData data, uint8_t val) — вернёт цвет data , яркость которого понижена на val (0-255).
  • uint32_t getHEX(mData data) — вернёт HEX RGB888 вне зависимости от выбранной цветовой глубины (функция распакует и вернёт в привычном представлении)
  • RGB888to565(x) , RGB888to323(x) , RGB565to888(x) , RGB323to888(x) — макросы конвертации цвета из одной кодировки в другую (принимает численное значение).
  • getR(mData x) — извлечь красный канал из цвета
  • getG(mData x) — извлечь зелёный канал из цвета
  • getB(mData x) — извлечь синий канал из цвета
  • mergeRGB(r,g,b) — объединить три цвета (0-255 каждый) в mData с учётом выбранной модели CRT гамма-коррекции
  • mergeRGBraw(r,g,b) — объединить три цвета (0-255 каждый) в mData
  • fade8(byte x, byte b) — уменьшить яркость x (0-255) на b (0-255)
  • fade8R(mData x, byte b) — уменьшить яркость красного канала цвета x на b (0-255)
  • fade8G(mData x, byte b) — уменьшить яркость зелёного канала цвета x на b (0-255)
  • fade8B(mData x, byte b) — уменьшить яркость синего канала цвета x на b (0-255)
  • getCRT(byte x) — получить скорректированное значение яркости x с учётом выбранной модели CRT гамма-коррекции
  • getCRT_PGM(byte x) — получить CRT из прогмем (работает только если выбрана PGM модель)
  • getCRT_SQUARE(byte x) — получить CRT по квадратной модели
  • getCRT_QUBIC(byte x) — получить CRT по кубической модели
  • RGB24to16(x) — конвертация 24-бит цвета в 16-бит
  • RGB24to8(x) — конвертация 24-бит цвета в 8-бит
  • RGB16to24(x) — конвертация 16-бит цвета в 24-бит
  • RGB8to24(x) — конвертация 8-бит цвета в 24-бит
  • RGB24toR(x) — вытащить байт R из 24-бит цвета
  • RGB24toG(x) — вытащить байт G из 24-бит цвета
  • RGB24toB(x) — вытащить байт B из 24-бит цвета
  • RGBto24(r,g,b) — склеить 24-бит цвет
  • RGBto16(r,g,b) — склеить 16-бит цвет
  • RGBto8(r,g,b) — склеить 8-бит цвет

ГРАДИЕНТЫ

В библиотеке реализован инструмент для создания градиентов любого размера (количество цветных сегментов) и длины:

РАБОТА С ЛЕНТОЙ ПОПИКСЕЛЬНО

Можно присвоить цвет в формате mData напрямую в буфер: strip.leds[0] = mRed . Есть функция set, которая делает то же самое:

set(num, color) — установить светодиоду под номером num цвет color . Например strip.set(0, mWheel(120));

fade(int num, byte val) — уменьшить яркость светодиода num на величину val

get(num) — вернёт цвет в формате mData . Равносильно чтению элемента массива буфера strip.leds[num] . Полученный цвет можно фейдить и применять к нему другие описанные выше модификаторы.

ЗАЛИВКА УЧАСТКОВ

  • clear() — очистить все цвета в буфере (погасить светодиоды)
  • fill(color) — залить всю ленту цветом color . Например fill(mRGB(120, 50 96))
  • fill(from, to, color) залить цветом color , со светодиода from до to
  • fillGradient(from, to, color1, color2) — залить градиентом от color1 до color2 между светодиодами from и to

Примечание: это функции для работы с буфером. Для применения нужно вызвать show() . Для потокового вывода эти функции не работают!

ЯРКОСТЬ

Яркость задаётся в setBrightness(val) в диапазоне 0-255. Установка яркости занимается дополнительным уменьшением яркости, то есть если поставить цвет mRed и максимальную яркость — это будет 255 по красному каналу цвета (максимум). Если поставить яркость 128, красный канал пропорционально уменьшится, остальные каналы останутся нулями.

РАБОТА С МАТРИЦЕЙ

Для работы с матрицей при инициализации, помимо настроек шаблона ленты, нужно указать параметры матрицы: ( width, height, type, conn, dir) . Где width и height — ширина и высота матрицы, type , conn и dir — тип соединения матрицы, угол и направление подключения (см. картинки к документации).

Так как матрица — это все ещё лента, у каждого пикселя помимо двух координат есть номер в ленте. Получить его можно при помощи getPixNumber(x, y) . Система координат — первая четверть декартовой СК: начало (0, 0) — левый нижний угол. Вверх растёт y, вправо — x.

  • set(x, y, color) — включит указанный пиксель указанным цветом в формате mData
  • get(x, y) — прочитает цвет пикселя
  • drawBitmap8(int X, int Y, const uint8_t *frame, int width, int height) — вывод битмапа (битмап 1мерный PROGMEM)
  • drawBitmap16(int X, int Y, const uint16_t *frame, int width, int height) — вывод битмапа (битмап 1мерный PROGMEM)
  • drawBitmap32(int X, int Y, const uint32_t *frame, int width, int height) — вывод битмапа (битмап 1мерный PROGMEM)

ОГРАНИЧЕНИЕ ТОКА (ЯРКОСТИ)

В библиотеке есть возможность автоматически ограничить яркость ленты по установленному току потребления при помощи setMaxCurrent(cur) , где cur — ток в миллиамперах. В самой библиотеке ток каждого типа ленты уже задан, но я измерял его для своих лент, и он может отличаться от лент, купленных в другом магазине. Для наиболее точной работы ограничения нужно настроить ток ленты для своей ленты, задав в oneLedMax максимальный (белый, 255) ток одного светодиода в миллиамперах и oneLedIdle — холостой ток (светодиод выключен) в мкА.

Берём кусок ленты, например WS2818, 180 диодов (3 в каждом секторе, 60 секторов):

  • 160 мА когда горит один сектор из 60
  • 114 мА когда лента не горит

Так как активный ток равен холостому + активному, 160-114 = 46 чистых мА на сектор имеем 114 / 60 = 1.9 мА холостых на сектор

Берём бухту ленты, например WS2812, 60*5м = 300 диодов

  • 102 мА когда горит один диод
  • 74 мА когда лента не горит

Так как активный ток равен холостому + активному, 102-74 = 28 чистых мА на диод имеем 74 / 300 = 0.24 мА холостых на диод

Источник

Adblock
detector