День #12: RGB LED-лента!

День 12 адвент-календаря для мейкеров — RGB LED-лента

Это финальный день адвент-календаря «12 проектов Кодмас»! Сегодня мы поиграем с RGB LED-лентой — но это не обычные светодиоды, это адресные светодиоды. Это значит, что мы можем запрограммировать самые разные цвета, паттерны и последовательности!

Время для ультра-праздничных миганий!

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

Содержимое коробки #12 

В этой коробке вы найдёте:

1x Специальная адресная LED-лента с разъёмами-«мама»

Проект сегодняшнего дня 

Сегодня — ГРАНДИОЗНЫЙ день! Мы научимся зажигать светодиоды на ленте по отдельности, программировать разные цвета и списки цветов, создавать световую гонку, затем управлять скоростью световой гонки с помощью потенциометра из дня #4, управлять цветом кнопкой, а также делать эффекты затухания — ФУХ!

Прежде чем начать, поговорим о том, что такое адресный светодиод…

Адресные RGB-светодиоды 

Светодиоды на вашей ленте — это WS2812 Адресные светодиоды, которые иногда называют «NeoPixels» (фирменное название от наших друзей из Adafruit).

Это особый вид светодиодов, внутри каждого из которых находятся три маленьких светодиода — один красный, один зелёный и один синий, которые мы смешиваем, чтобы получить множество разных цветов с помощью кода. Именно поэтому лента называется RGB — R ed (красный), G reen (зелёный), B lue (синий)! Подробнее об этом чуть позже.

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

При работе с более длинными лентами обычно приходится беспокоиться о внешнем питании, резисторах и других технических деталях, однако специальная компактная лента в вашей коробке достаточно короткая, чтобы избежать всех этих сложностей. На этот раз мы будем питать её от другого пина — VBUS (физический пин 40), так как он обеспечит полные 5В, которые нужны ленте, а не 3,3В, которые мы использовали до этого.

Мы также заказали эту LED-ленту специально для этого календаря с удобными jumper-проводами, чтобы вам не пришлось возиться с разъёмами и инструментами.

Шаг 1: Сборка схемы 

Отключите Pico от USB-порта компьютера, чтобы безопасно изменить схему.

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

Затем возьмите LED-ленту и подключите три провода следующим образом:

Вставьте красный провод в пин VBUS (физический пин 40) — на этот раз НЕ в пин 3V3!
Вставьте чёрный провод в пин GND, который является физическим пином 38.
Вставьте зелёный провод в GPIO 28 (физический пин 34)

Далее добавляем одну из кнопок и потенциометр. Разместите их слева от Pico, как показано ниже — помните, что у вашего потенциометра будет зазор между каждой из ножек, в отличие от нашей схемы:

Далее подключаем кнопку. Кнопке нужны обычные 3,3В, а не 5В на пине VBUS, который мы используем для LED-ленты:

Соедините левую ножку кнопки с верхним красным каналом
Соедините правую ножку кнопки с GPIO 15 (физический пин 20)
Затем используйте ещё один провод, чтобы соединить пин 3,3В (физический пин 36) с верхним красным каналом

Наконец подключаем потенциометр тремя проводами:

Соедините левую ножку с пином GND на физическом пине 18
Соедините среднюю ножку с GPIO 26 (физический пин 31)
Соедините правую ножку с верхним красным каналом (3,3В)

Задание 1: Минимальная стартовая программа — один светодиод 

Время зажечь огни — подключите Pico обратно к USB-порту компьютера, и мы запустим это шоу!

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

Этот минимальный пример зажигает первый светодиод красным цветом — просто чтобы разобраться с тем, как работает библиотека, которая теперь включена в MicroPython и не требует отдельной установки. Удобно!

Эти ленты могут отображать множество разных цветов, поскольку являются RGB-лентами — давайте сначала разберёмся с этим.

Что такое RGB?

RGB расшифровывается как R ed G reen B lue (красный, зелёный, синий) — это цветовая система, используемая в вычислительной технике для отображения цветов на экране компьютера.

Три цвета можно комбинировать, чтобы получить огромное разнообразие различных цветов. В RGB каждый из трёх цветов можно задать значением интенсивности от 0 до 255. Поскольку каждый из трёх цветов имеет 255 возможных различных значений интенсивности, технически существует 16 777 216 возможных комбинаций цветов (хотя ваши глаза, вероятно, не заметят разницы между многими из них при использовании с светодиодами).

RGB и светодиоды 

Как это связано с нашей LED-лентой? Как мы уже упоминали, внутри каждого из этих умных светодиодов находятся три меньших светодиода — один красный, один зелёный и один синий. Мы отправляем код на ленту, чтобы задать значение RGB-интенсивности для каждого светодиода, позволяя ему смешивать и показывать разные цвета. Здорово, правда?!

Существует множество онлайн-инструментов для поиска значений RGB для нужного цвета, например страница RapidTables. Например, базовый красный — это 255,0,0.

Код 

Наш пример кода импортирует «neopixel» — это название библиотеки, теперь включённой в MicroPython для управления такими адресными светодиодами.

Для настройки LED-ленты строка 7 задаёт номер пина для ленты (GPIO28) и количество светодиодов на ленте (15). Теперь мы можем обращаться к ней в коде через «strip».

Для отправки данных на LED-ленту мы сначала записываем, что хотим, чтобы она делала, а затем используем strip.write(), чтобы отправить это на ленту — примерно так же, как работал наш OLED-дисплей вчера.

В примере ниже мы используем strip[0] = (255,0,0). [0] говорит нашей ленте управлять только первым светодиодом, потому что первый светодиод начинается с 0, второй — это 1 и так далее. Числа в скобках — это значение RGB — мы используем 255,0,0, что является красным с максимальной интенсивностью.

Скопируйте пример ниже в Thonny, запустите код, затем выполните следующие задания, чтобы освоиться:

Попробуйте изменить 255 на 10 — что происходит? Интенсивность должна снизиться.
Попробуйте изменить значение RGB на 0,10,0 — что происходит? Цвет должен измениться на зелёный.
Теперь попробуйте изменить [0] на [7] — что происходит? Должен загореться 8-й светодиод (потому что помните, нумерация светодиодов начинается с 0).
Используйте онлайн-инструмент выбора RGB-цвета, чтобы найти и отобразить ваш любимый цвет.

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Выбираем первый пиксель (пиксель 0)
# Задаём RGB-цвет (красный)
strip[0] = (255,0,0)

# Отправляем данные на ленту
strip.write()

Задание 2: Использование нескольких светодиодов 

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

Чтобы зажечь больше светодиодов, нам нужно сообщить MicroPython, какие именно светодиоды мы хотим использовать. До сих пор мы говорили MicroPython зажечь только светодиод 0 (первый светодиод).

Базовый метод 

Базовый способ — просто добавить больше строк, меняя [0] на нужный номер светодиода.

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

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Выбираем первый пиксель (пиксель 0)
# Задаём RGB-цвет (красный)
strip[0] = (255,0,0)
strip[1] = (255,0,0)
strip[2] = (255,0,0)
strip[3] = (255,0,0)
strip[4] = (255,0,0)

# Отправляем данные на ленту
strip.write()

Лучший метод 

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

Единственное, что меняется в нашем коде — это номер пина для каждого из 15 светодиодов, поэтому мы можем воспользоваться циклом for и функцией range, которые мы использовали ранее.

Мы используем цикл for для перебора каждого светодиода на нашей ленте. Мы знаем, что у нас 15 светодиодов, поэтому используем for i in range(15):, чтобы этот блок кода выполнялся для диапазона из 15.

Этот диапазон (с помощью i) «подставляется» в строку с LED-лентой, так как мы используем strip[i] = (255,0,0). Это происходит для всего диапазона из 15 светодиодов, а затем, когда цикл for завершится, последняя строка записывает эти данные на ленту, и они все загораются.

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

Попробуйте пример кода ниже (мы выбрали жёлтый цвет):

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Перебираем 15 светодиодов
for i in range(15):

    # Задаём каждому светодиоду в диапазоне жёлтый цвет
    strip[i] = (255,255,0)

# Отправляем данные на ленту
strip.write()

Ещё лучший метод!

Хотите просто зажечь всю ленту без какой-либо гибкости? Это очень просто — используйте strip.fill((255,0,0)), и загорится столько светодиодов, сколько вы задали в строке настройки (15 для нас). С этой функцией обязательно используйте два набора скобок!

Попробуйте простой пример ниже (немного бирюзового?), затем поиграйте с RGB-кодами цветов:

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Заполняем ленту бирюзовым цветом
strip.fill((72,209,204))

# Отправляем данные на ленту
strip.write()

Задание 3: Лучшее управление цветами 

Теперь мы знаем, как зажечь несколько светодиодов, и знаем, как создавать RGB-цвета. Давайте покажем вам несколько приёмов, которые помогут управлять цветами чуть удобнее, а затем перейдём к по-настоящему увлекательным вещам!

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

Переменные цветов 

Мы много использовали переменные за последние двенадцать дней, поэтому вы, возможно, уже знаете, что делать — но мы покажем на случай, если нет!

Мы возьмём пример выше (задание 2) и добавим переменные для пяти разных цветов. Затем мы сможем использовать эти цвета в коде LED-ленты, легко меняя цвет просто по названию — например, strip[i] = (red).

Попробуйте код ниже, а потом измените название цвета в скобках на одно из наших переменных:

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Переменные цветов
red = 255,0,0
green = 0,255,0
blue = 0,0,255
yellow = 255,255,0
pink = 255,20,147

# Перебираем 15 светодиодов
for i in range(15):

    # Задаём каждому светодиоду в диапазоне розовый цвет
    strip[i] = (pink)

# Отправляем данные на ленту
strip.write()

Списки цветов 

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

Списки 

Списки — ещё один удобный инструмент для вашего набора MicroPython. Фактически это переменная с несколькими элементами внутри. Элементами внутри могут быть данные любого типа — строки, целые числа, переменные и т.д. — всё просто!

Давайте запустим короткий пример, а затем используем списки в следующем задании.

Короткий пример ниже создаёт список под названием «mylist» и включает четыре строки в квадратных скобках, разделённые запятыми. Вот и всё — списки именно такие простые!

В нашем примере мы затем выводим этот список, используя имя списка (переменную) в строке print. Поместите это в Thonny и попробуйте:

mylist = ["Dasher","Dancer","Prancer","Vixen"]

print(mylist)

Задание 4: Световая гонка 

Давайте ускоримся и создадим что-то по-настоящему крутое — световую гонку. Как же это по-праздничному!

В нашем примере ниже мы создали список из переменных цветов под названием colours. Мы также поместили код LED в бесконечный цикл while, который содержит цикл for с вложенным циклом for внутри него.

Зачем нужен вложенный цикл for?

Вложенный цикл for позволяет нам сначала перебирать цвета, а затем перебирать светодиоды.

Код говорит: «Для каждого цвета в списке цветов выполни мой блок кода» — а этот блок кода содержит ещё один цикл for, который применяет этот цвет к нашему диапазону из 15 светодиодов. После того как диапазон заканчивается, он возвращается к начальному циклу for для следующего цвета и делает всё это снова.

Мы используем j для цветов и i для диапазона светодиодов — если помните из предыдущих коробок, неважно, что мы здесь используем. Мы могли бы использовать «colour» вместо «j» и «led» вместо «i». Никаких правил здесь нет, только традиции!

Когда записывать данные 

Ещё одно ключевое изменение — момент, когда мы записываем данные на ленту.

Раньше strip.write() находился за пределами и после цикла for, ожидая, пока цикл завершит установку всех 15 светодиодов, прежде чем записать данные. На этот раз мы записываем данные внутри цикла for после каждой итерации (после каждого отдельного светодиода).

Это означает, что цикл for находит следующий светодиод в диапазоне и зажигает его прежде чем переходит к следующему, что создаёт эффект гонки на LED-ленте, а не записывает все 15 одновременно.

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

Это много для усвоения, поэтому попробуйте код ниже и перечитывайте вышесказанное, пока наблюдаете за сиянием. Мы также призываем добавить больше цветов и поиграть с задержкой по времени (при установке 0.01 мигание будет очень быстрым!):

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Переменные цветов
red = 255,0,0
green = 0,255,0
blue= 0,0,255

# Задаём список цветов
colours = [red, green, blue]

while True: # Запускаем бесконечно

    # Перебираем цвета
    for j in colours:

        # Затем перебираем 15 светодиодов
        for i in range(15):

            # Задаём каждому светодиоду в диапазоне цвет
            strip[i] = (j)

            # Задержка — скорость гонки
            time.sleep(0.1)

            # Отправляем данные на ленту
            strip.write()

Задание 5: Световая гонка с регулировкой скорости 

Теперь мы снова задействуем потенциометр в нашем коде, чтобы управлять скоростью световой гонки. Мы используем показание АЦП потенциометра и применим его для управления переменной задержки по времени — точно так же, как мы делали в коробке #4 для управления скоростью мигания светодиодов.

Код 

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

Добавить ADC в наши импорты
Настроить GPIO-пин для потенциометра
Добавить строку кода внутри вложенного цикла for для считывания потенциометра в переменную, затем разделить это число, чтобы сделать его более удобным в качестве задержки по времени
Использовать эту переменную считывания для управления задержкой по времени

Совет: если бы мы не делили показание датчика, мы отправляли бы значения от 0 до 65535 в нашу задержку (в секундах), что было бы слишком медленно для эффекта, который мы хотим получить.

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

Вы можете изменить число, на которое мы делим показание, чтобы увеличить/уменьшить минимальную задержку, или, возможно, добавить ещё любимых цветов в виде переменных и включить их в список?

# Импорты
import time
from machine import Pin, ADC
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Настраиваем потенциометр на АЦП пин 26
potentiometer = ADC(Pin(26))

# Переменные цветов
red = 255,0,0
green = 0,255,0
blue= 0,0,255

# Задаём список цветов
colours = [red, green, blue]

while True: # Запускаем бесконечно

    # Перебираем цвета
    for j in colours:

        # Затем перебираем 15 светодиодов
        for i in range(15):

            # Задаём следующему светодиоду в диапазоне цвет
            strip[i] = (j)

            # Считываем потенциометр
            # Делим показание, чтобы сделать его более удобным в качестве задержки
            mydelay = potentiometer.read_u16() / 50000

            # Задержка — скорость гонки
            time.sleep(mydelay)

            # Отправляем данные на ленту
            strip.write()

Задание 6: Управление цветом кнопкой 

Мы вернёмся к использованию strip.fill для полного заполнения LED-ленты одним цветом, однако на этот раз мы будем использовать нашу кнопку для смены цвета ленты. Это звучит просто, но нам нужно изменить наш подход, чтобы это работало.

Вместо того чтобы вводить цвет прямо в код с помощью чего-то вроде strip.fill((red)), или использовать цикл for для автоматического перебора списка цветов по порядку, мы воспользуемся другим методом, который использует индекс каждого цвета в нашем списке цветов… но что такое индекс?

Что такое индекс списка?

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

Возьмём наш текущий список — [red, green, blue]. Индекс для этого списка будет 0, 1 и 2. 0 = красный, 1 = зелёный и 2 = синий.

Мы можем использовать это, чтобы выбрать конкретный цвет из нашего списка, изменив то, как мы используем строку strip.fill. Например, strip.fill((colours[1])) использует индекс 1 из списка colours — это зелёный.

Вероятно, вы думаете: «но мы могли бы просто использовать strip.fill((green))». Это правда, однако поскольку индекс использует число, это позволяет нам легко изменять это число (и, следовательно, цвет) с помощью нашей кнопки через переменные.

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

Подождите, кто такой Len?

Не кто, а len! Мы используем len для получения количества элементов в списке. Мы просто используем «len», за которым в скобках следует имя списка.

Если наш список выглядит так:

colours = [red, green, blue]

Тогда мы используем len следующим образом, чтобы подсчитать и вывести количество элементов в нашем списке (которое будет равно 3):

print(len(colours))

Попробуйте следующий краткий пример, чтобы увидеть это в действии:

# Переменные цветов
red = 255,0,0
green = 0,255,0
blue= 0,0,255

# Задаём список цветов
colours = [red, green, blue]

print(len(colours))

Код 

Здесь всё вышесказанное должно сложиться воедино и иметь смысл (надеемся!).

В примере кода ниже есть несколько новых переменных:

myindex — мы используем её как номер индекса для выбора цвета из нашего списка. Мы меняем это число при нажатии кнопки, чтобы перейти к следующему номеру в индексе (следующему цвету)
indexlength — это подсчитывает количество элементов в нашем списке цветов (3, в нашем примере). Однако, поскольку мы используем это для идентификации последнего числа в нашем индексе, нам нужно в конце сделать -1 (потому что в списке 3 элемента, но поскольку они индексируются как 0, 1 и 2, мы хотим, чтобы максимальное значение индекса было 2)

Пример кода ниже использует цикл while, который ничего не делает (просто задержка), пока не будет нажата кнопка. После нажатия кнопки используется условный оператор if для проверки текущего значения переменной myindex.

Если переменная myindex меньше переменной indexlength (если myindex меньше 2), она добавляет +1 к переменной myindex. Мы также используем оператор else под этим (для случая, когда myindex равен 3), который сбрасывает myindex обратно в 0.

Независимо от того, сработал оператор if или else, оба изменят переменную myindex, а затем перейдут к коду ниже них.

Эти финальные строки кода обновляют strip.fill с номером индекса, используя переменную myindex, а затем записывают данные на LED-ленту. Мы записываем данные на LED-ленту только здесь — это означает, что данные записываются только при изменении; если кнопка не нажата, ничего не происходит.

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

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём пин кнопки
button = Pin(15, Pin.IN, Pin.PULL_DOWN)

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Переменные цветов
red = 255,0,0
green = 0,255,0
blue= 0,0,255

# Задаём список цветов
colours = [red, green, blue]

# Создаём переменную индекса, начиная с 0
myindex = 0

# Переменная с количеством элементов в нашем списке (3)
# Делаем -1, так как индекс начинается с 0, и хотим использовать это для номера индекса списка цветов (0, 1 или 2)
# Это удобно, так как означает, что нам не нужно считать цвета, если мы добавим ещё
indexlength = len(colours) -1

while True: # Запускаем бесконечно

    time.sleep(0.4) # Задержка

    if button() == 1: # Если кнопка нажата

        # Если переменная индекса меньше длины индекса
        if myindex < indexlength:

            # Добавляем +1 к переменной индекса
            myindex = myindex + 1

        # Если переменная индекса превышает длину индекса
        else:

            # Сбрасываем переменную индекса обратно в 0 (первый элемент нашего списка)
            myindex = 0

        ## Теперь этот код запускается ПОСЛЕ условных операторов...

        # Заполняем ленту цветом с текущим индексом списка
        strip.fill((colours[myindex]))

        # Записываем данные на LED-ленту
        strip.write()

Задание 7: Плавное затухание 

Теперь попробуем сделать так, чтобы наша LED-лента плавно появлялась и гасла — это удивительно просто с помощью простого кода цикла for, и это даёт нам возможность показать ещё один способ использования функции range.

Наш пример ниже использует цикл while с двумя циклами for внутри него, оба используют функцию range.

Эти циклы for перебирают значение красного R (из RGB), используемое в строке strip.fill ниже них, так что каждая итерация изменяет значение R. Вы можете видеть, где мы используем i вместо значения в strip.fill((i,0,0)).

Дополнительные параметры range 

Вы также заметите, что скобки range содержат три числа! Раньше мы просто указывали одно число для перебора, а использование трёх значений (параметров) позволяет задать:

Начало диапазона
Конец диапазона
Шаг для каждой итерации

Наш пример ниже использует for i in range(0,255,1), что устанавливает начало диапазона на 0, конец диапазона на 255 и говорит коду увеличиваться на 1 шаг при каждой итерации.

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

Следующий цикл for делает то же самое, но в обратном порядке. Да — вы можете идти в обратном направлении с функцией range! Поэтому мы устанавливаем наш диапазон, чтобы начинать с 255 вместо 1, и заканчивать на 1 вместо 255. Шаг равен -1, так что мы постоянно вычитаем 1 из начального значения 255.

Попробуйте код ниже, затем поэкспериментируйте со значениями цветов — попробуйте использовать i в других местах, например strip.fill((i,0,i)), или добавьте фиксированные значения к другим цветам, например strip.fill((i,0,50)):

# Импорты
import time
from machine import Pin
from neopixel import NeoPixel

# Задаём номер пина ленты (28) и количество светодиодов (15)
strip = NeoPixel(Pin(28), 15)

# Переменная для скорости затухания
delay = 0.005

while True: # Запускаем бесконечно

    # Перебираем от 1 до 255 с шагом 1
    for i in range(1,255,1):

        # Заполняем ленту используя перебираемое значение R
        strip.fill((i,0,0))

        # Записываем данные на LED-ленту
        strip.write()

        # Задержка
        time.sleep(delay)

    # Перебираем от 255 до 1 с шагом -1
    for i in range(255,1,-1):

        # Заполняем ленту используя перебираемое значение R
        strip.fill((i,0,0))

        # Записываем данные на LED-ленту
        strip.write()

        # Задержка
        time.sleep(delay)

День #12 завершён!

Сегодня было немного дольше, чем в некоторые другие дни, потому что LED-ленты — такая весёлая и универсальная деталь для работы (и с ними можно сделать так много всего!).

Мы уверены, что многие из вас превратят свою ленту в стильную подсветку монитора — возможно, некоторые объединят её с PIR, чтобы она включалась при наличии движения перед их ПК, или, может быть, умело скрытые датчики прерывания луча будут использованы в качестве переключателя цветов с управлением рукой? Что бы вы ни создали, нам очень интересно узнать о ваших проектах!

Итак, что мы рассмотрели в день #12? Сегодня вы:

Узнали, что такое адресный светодиод и почему они такие весёлые!
Построили схему с адресными светодиодами
Узнали об RGB и о том, как создавать цвета с помощью значений RGB (и где их найти)
Научились программировать адресные светодиоды с помощью MicroPython
Узнали разные способы зажечь всю ленту… некоторые из них эффективнее других!
Создали переменные цветов
Узнали, как создавать и использовать списки в MicroPython, включая индексы списков
Использовали вложенные циклы for
Узнали, как использовать len в MicroPython
Применили плавное затухание адресных светодиодов с помощью range (как по возрастанию, так и по убыванию)

Дальше — за вами!

Это всё, друзья, — конец адвент-календаря для мейкеров. Мы знаем, что многие из вас хотели, чтобы он продолжался традиционные 25 дней, однако мы хотели сделать его доступным по цене и возможностям для как можно большего числа людей.

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

Мы лишь поверхностно прикоснулись к тому, что возможно с этим фантастическим маленьким микроконтроллером и компонентами, которые вы открыли за последние 12 дней — ещё так много предстоит узнать и испытать!

Дополнительные ресурсы 

Интернет переполнен проектами и примерами, использующими Raspberry Pi Pico и MicroPython, и 99,9% этой информации бесплатно — так что не останавливайтесь! Некоторые отличные примеры появлялись от мейкеров в разделах комментариев к календарю по ходу дела.

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

Хорошей отправной точкой для вдохновения и замечательным сообществом является форум Raspberry Pi, в частности раздел Pico. Только не забывайте всегда искать, прежде чем задавать вопрос!

Схемы подключения на макетной плате для этой страницы созданы с помощью Fritzing.