Гирлянда на Arduino
В прошлой статье мы проводили эмуляцию работы Arduino в программе Proteus. Но гораздо интереснее прошить реальный Arduino и понаблюдать за результатами в живую, чем мы и займемся в этой статье. Думаю, многим уже надоел банальный моргалик на одном светодиоде. Поэтому, чтобы порадовать глаз и потешить себя, мы будем собирать гирлянду сразу на 5 светодиодах.
Пишем программу
Первым делом открываем нашу среду разработки, знакомую вам еще с прошлой статьи:
Больше всего нас интересуют вот эти два блока:
Void setup. Сюда мы вписываем конфигурацию выводов нашей Arduino. Строчка «put your setup code here, to run once» в дословном переводе означает «поместите ваш код установки здесь, чтобы запустить один раз».
Void loop. Здесь у нас будет программа, которая будет «крутиться» в бесконечном цикле. Строчка «put your main code here, to run repeatedly» в дословном переводе «поместите ваш основной код здесь, чтобы запустить повторно».
Ну что, погнали писать!
pinMode — режим вывода
Output — выход
Выводы Arduino под номерами 3,4,5,6,7 мы «заставляем» быть выходами. То есть они нам буду выдавать либо логический ноль (напряжения нет), либо единичку (напряжение есть).
Знак «//» и текст после него — это комментарии, которые удобны для нас, чтобы понять что вообще происходит в программе, но эти комментарии не играют никакой роли при компиляции, так как компилятором они просто игнорируются.
Далее продолжаем писать программку с первым эффектом моргания:
Ну здесь тоже все до боли просто.
DigitalWrite — записываем «цифру»
High — высокий
Low — низкий
Думаю, тут понятно все без слов. Выдаем на какой-либо вывод сигнал высокого или низкого уровня, то есть единичку или ноль.
Delay — задержка в миллисекундах.
Ну и потом добавляем еще 4 эффекта. Я покажу только конец программы, то есть 5-ый эффект, чтобы вы увидели, что цикл void loop должен закрываться фигурной скобочкой:
Прошиваем в железе
Ну а теперь дело за малым. Прошиваем нашу Arduino в реальности! Все это дело соберем вот по такой схемке:
Как мы видим светодиоды подключены у нас к тем самым цифровым выводам с 3 по 7. Для того чтобы реальные светодиоды у вас не сгорели от напряжения питания Ардуино Уно, которое составляет 5 вольт, я поставил на схеме токоограничительные резисторы, по отдельному на каждый светодиод.
Примерно вот так все это будет выглядеть в живом виде:
Теперь берем кабель, который шел (а может быть и не шел) в комплекте с Arduino:
Один конец подключаем к Arduino, а другой конец — к компьютеру:
Запускаем нашу программку Arduino 1.6.7 и выбираем программку, которую будем зашивать. В нашем случае мы зашиваем программку из 5 светодиодов:
Далее убеждаемся, что наша плата Arduino Uno подружилась с компьютером. Смотрим, что говорит нам компьютер:
Ага, Arduino/Genino Uno. Все ОК.
Теперь убеждаемся, что COM-порт у нас выбран правильно. Смотрим в «Диспетчере устройств», на какой COM-порт встала наша Arduino:
Проверяем теперь в Arduino. Если не так, то ставим галочку на нужный порт. У меня галочка тоже стоит на COM8:
На а далее дело за малым. Скетч—->Загрузка:
Источник: https://www.ruselectronic.com/arduino-girlyanda-iz-5-svetodiodov/
Смарт часы с RGB светодиодами на основе Arduino
Смарт часы с RGB светодиодами на основе Arduino
Вам нужны смарт-часы? Вот вам часы с RGB светодиодам на основе Arduino, которые не только показывают время, но также будут выражать вашу индивидуальность.
Вы не найдете ни одной цифры на этих часах; вместо этого, они используют RGB светодиоды для индикации времени, а именно “стрелка” часов светится синем, минуты – красным и секунды – зеленым цветом. Кроме того, емкостной сенсорный выключатель на ремешке активирует режим фонарика в течении 10 секунд.
Формат времени:Часы: 1 светодиод = 1 часМинуты: 1 LED = 5 минут
Секунды: 1 LED = 5 секунд
С точки зрения электроники, часы оснащены платой Arduino Pro Mini, 12-bit RGB Ring, модуль часов реального времени DS1307, литий-ионный аккумулятор 3.7 V 850mAh, резистор на 1МОм, Step-Up voltage regulator 5v -все они размещаются внутри простой картонной коробки с куском прозрачного органического стекла.
Схема соединения
Как вы видите на схеме, модуль DS1307 RTC нужно подключить к интерфейсу TWI (I2C) платы Arduino (аналоговые контакты 5 (SCL) и 4 (SDA)). RGB кольцо подключается к контакту 3 к Arduino.Резистор1M Ом подключается контактов 10 и 13 вместе. Провод сенсора подключается к контакту 10.
Все GND и VSS контакты соединены с регулятором повышающего напряжения (нету ни на одной из схем).
Соединение элементовСначала нужно припаять резистор 1М Ом к выводам 13 и 10, потом припаять 3 провода для RGB кольца и еще один для штифта 10.
После этого ye;yj подключить повышающий регулятор с GND часов реального времени и VSS, а затем снова подключен SDA, SCL, GND и VSS из RTC с Arduino Pro Mini плате пайкой проводов.
В конце концов, с помощью горячего клея все вместе нужно прилепить как можно компактно.
Изготовления корпуса
Для корпуса можно использовать простую картонную коробку, которую можно сделать используя кусок картона и кусочек прозрачного органического стекла, 37 х 37 мм и толщиной 3 мм, как сверху.
Размер коробки 37 мм х 37 мм х 15 мм. Также нада сделать 2 отверстия, на дне коробки, для силовых проводов.
Для ремешка можно использовать длинный кусок ~ 20 см х 2,5 см (материал подбирайте сами) и кусочки липучки на обоих концах.
Программа
Вам будут нужны следующие библиотеки
Adafruit_NeoPixel
Time
DS1307RTC
CapacitiveSensor
Саму программу можете скачать здесь Скачать файл: pixie_v1.0.zip [1,9 Kb] (cкачиваний: 31) Вот представлена работа часов
Источник
Источник: https://ngin.pro/arduino/122-smart-chasy-s-rgb-svetodiodami-na-osnove-arduino.html
Урок 1 – Мигаем встроенным на плату Arduino светодиодом
На плату Arduino UNO (Nano, Mega, micro и пр.) установлен светодиод который соединен с 13 pin платы. На плате он обозначается буквой L.
Для того чтобы заставить мигать встроенный светодиод на плату Arduino. Достаточно загрузить не большую программу.
Для урока нам понадобиться:
- Arduino UNO или Arduino Nano
/* Зажигаем светодиод на одну секунду, затем выключаем его на одну секунду в цикле. */ void setup() { // Инициализируем цифровой вход/выход в режиме выхода. // Выход 13 на большинстве плат Arduino подключен к светодиоду на плате. pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); // зажигаем светодиод delay(1000); // ждем секунду digitalWrite(13, LOW); // выключаем светодиод delay(1000); // ждем секунду }
Функция setup() вызывается, когда стартует скетч. Используется для инициализации переменных, определения режимов работы выводов, запуска используемых библиотек и т.д. Функция setup запускает только один раз, после каждой подачи питания или сброса платы Arduino.
pinMode(13, OUTPUT); Инициализируем цифровой вход/выход в режиме выхода. Этого можно не делать так как цифровые выходы Ардуины по умолчанию настроенные на режим выход.
После вызова функции setup(), которая инициализирует и устанавливает первоначальные значения, функция loop() делает точь-в-точь то, что означает её название, и крутится в цикле, позволяя вашей программе совершать вычисления и реагировать на них. Использовать её нужно для активного управления платой Arduino.
DigitalWrite() – Так как у нас пин настроен как выход (pinMode(13, OUTPUT);), то для значение HIGH напряжение на соответствующем вход/выходе (pin) будет 5В (3.3В для 3.3V плат), и 0В(земля) для LOW.
Т.е. digitalWrite(13, HIGH); – На пин 13 подается 5 вольт.
digitalWrite(13, LOW); – На пин 13 подается 0В.
delay() – Останавливает выполнение программы на заданное в параметре количество миллисекунд (1000 миллисекунд в 1 секунде).
Следующий урок: Мигаем светодиодом подключенным к 2 pin Arduino
Если у вас чего то нет для выполнения данного урока, Вы можете посмотреть в каталоге. Там собранные комплектующими от проверенных продавцов по самым низким ценам.
Источник: https://portal-pk.ru/news/1-urok-1—miganie-vstroennym-na-platu-arduino-svetodiodom.html
Arduino — мигание светодиодом
На сегодняшний день аппаратная платформа управления периферическими приспособлениями на основе Ардуино приобрела чрезвычайно обширное распространение. Благодаря исключительной простоте управления и достаточно широким функциональным возможностям, подобные устройства активно применяются в самых разнообразных проектах, от управления моторчиками до систем «умный дом».
Ардуино что это?
Непосредственно сам модуль Ардуино представляет собой микропроцессор семейства Atmel AVR ATmega с набором портов способных принимать и транслировать информацию. Управление устройством совершается специальной программой-скетчем написанной на модифицированном С/С++. Язык программирования весьма лёгкий даже для абсолютных «чайников».
Программы пишутся в специальной оболочке:
Verify/Compile – проверяем валидность кода;
Upload to I/O Board – загружаем программу в Ардуино.
Загрузка исполняемого скетча
Если вы загружаете данные впервые, потребуется настроить параметры загрузки: Tools > Boardи Tools > Serial Port.
Порт подключения можно уточнить в диспетчере устройств (Панель управления > Диспетчер устройств> Порты (COM, LPT). В настройках требуется указать тип платы Ардуино в выпадающем списке.
После чего записывает в память устройства загрузчик (Bootloader).
Управление светодиодами
Управление светодиодами на ардуино позволяет реализовать самые разнообразные схемы: включение/отключение по нажатию кнопки, мигание, плавное включение/отключение.
Для работы со светодиодом нам потребуется простейшая программа для управления портами. Для ее написания используем лишь несколько базовых команд:
pinMode (порт, режим) – команда устанавливает режим работы вывода (порта) на плате. Порт – номер вывода, режим – OUTPUT (режим передачи) и INPUT (режим приёма информации).
digitalWrite (порт, значение) – команда объявления состояния порта. Порт – номер вывода, режим – HIGH (включён), LOW (выключен).
Delay (интервал) – задержка между выполнением команд. Интервал – количество миллисекунд.
Сам скетч представляет собой две функциональные части. Объявление переменных находится в модуле voidsetup () {…}, исполняемый код — voidloop () {…}.
Наглядно все можно увидеть на видео:
Мигаем светодиодом арудино
Код скетча для мигания светодиода (скетч для ардуино мигание светодиодом находится во встроенном скетче “blink”).
Мигаем с частотой 1 секунда.
Скетч мигание светодиодом на ардуино:
void setup () {
pinMode (9, OUTPUT); // устанавливаем вывод 9 в режим передачи
}
void loop() {
digitalWrite (9, HIGH); // подаём сигнал на порт 9 +5В
delay(1000); // ждем секунду
digitalWrite (9, LOW); // отключаем порт 9
delay(1000); // ждем секунду
}
Как подключить светодиод к ардуино
Подключение к ардуино желательно делать через резистор. В arduino подключение возможно и через встроенный резистор, но это требует специальный синтаксис команд и лучше его не использовать. Ограничительный резистор между выходом порта и светодиодом берем на 150 — 200 Ом.
Плавное включение светодиода
Для плавного включения используем новую команду ШИМ-модуляции сигнала.
Что бы понять принцип работы шим-модуляции, представьте резиновую трубку через которую в стакан течет вода. Если мы будем каждую секунду зажимать и отпускать трубку, за равный промежуток количество набранной воды уменьшиться в два раза. Если зажимать на одну секунду один раз в четыре секунды – ограничим объем жидкости на четверть.
В Ардуино модуляция сигнала происходит с частотой около 500 импульсов в секунду.
Команда analogWrite (порт, частота модуляции) подает на заданный порт модулированный сигнал. При частоте 255 выдается 100% мощности, при частоте 127 соответственно 50%. Изменяя частоту модуляции мы можем менять яркость. Для модулированного сигнала используют аналоговые входы-выходы.
void setup() // процедура setup
{
pinMode (6, OUTPUT); // включаем аналоговый порт 6 на вывод
}
void loop()
{
Цикл увеличения частоты модуляции с 0 до 255
For (int i=0; i=0;i—)
{
analogWrite(6, i);
delay(20);
}
В этом примере светодиод плавно разгорается за 5 сек. потом постепенно гаснет в течении 5 сек.
Для подключения большого количества светодиодов либо мощного светодиода требуются коммутаторы: транзисторный ключ, опотрон, микросхема коммутатор. Они позволяют подавать питание от внешнего источника достаточной мощности.
Оцените, пожалуйста, статью. Мы старались:) (Пока оценок нет)
Загрузка…
Источник: https://SvetodiodInfo.ru/texnicheskie-momenty/arduino-miganie-svetodiodom.html
Мигание встроенным на плату Arduino светодиодом
На этом уроке Вы научитесь программировать свою плату Arduino на примере мигания встроенным светодиодом.
Для данного примера Вам понадобится плата Arduino (в данном случае – Arduino Uno R3, но Вы сможете проработать данный пример, имея в наличии и другую плату) и кабель USB (типа A (4х12 мм) – B (7х8 мм) – более подробно можно почитать на Вики).
Что такое ” L” светодиод
На Arduino Uno присутствуют ряды коннекторов типа мама по бокам платы, которые используются для подключения периферийных электронных устройств или “шилдов”.
Кроме того, на плате присутствует встроенный светодиод (англ. – LED), которым Вы можете управлять с помощью скетчей. Этот встроенный светодиод условно назовем “L” светодиод, как это принято на многих англоязычных ресурсах.
Расположение данного светодиода на плате отмечено на фото снизу.
Загрузка примера “Blink” (мигание) в Arduino IDE
При подключении новой платы к персональному компьютеру, обратите внимание, что светодиод начинает мигать, так как все платы от производителей поступают с уже “залитым” скетчем “Blink”.
На этом уроке мы перепрограммируем нашу плату, изменив частоту мигания светодиода. Не забудьте настроить оболочку Arduino IDE и выбрать нужный серийный порт, по которому Вы подключили Вашу плату.
Пришло время проверить Ваше подключение и запрограммировать плату.
В оболочке Arduino IDE существует большая коллекция скетчей, которые уже готовы к использованию. Среди них находится и пример, который заставляет мигать “L” светодиод.
Откройте пример “Blink”, который находится в пункте меню File – Examples – 01.Basics
После открытия, расширьте окно оболочки Arduino IDE, чтобы Вы могли весь скетч в одно окне.
Скетчи из примеров, включенные в Arduino IDE предусматривают режим “только чтение” (“read only”). То есть, загрузить их на плату Вы сможете, но после изменения кода, Вы не сможете их сохранить в том же файле.
Мы будем изменять скетч, так что в первую очередь Вам необходимо сохранить собственную копию, которую Вы сможете изменять.
Из меню “File” выберите опцию “Сохранить как” (“Save As..”) и сохраните скетч под подходящим Вам названием, например, “MyBlink”.
Вы сохранили копию скетча “Blink” в Вашей библиотеке. Теперь открыть этот файл Вы можете в любой момент, перейдя по вкладке File – Scetchbook.
Загрузка примера “Blink” (мигание) на плату
Подключите свою плату Arduino к компьютеру с помощью USB и проверьте тип платы (“Board type”) и серийный порт (“Serial Port”), по которому она подключена.
Текущие настройки отображаются внизу окна оболочки Arduino IDE
Кликните на кнопку “Загрузить” (“Upload”)
Во время загрузки в нижней части окна IDE появятся ползунок загрузки и сообщения. Вначале появляется фраза “Компилирование” (“Compiling scetch..”), что означает процесс конвертирования Вашего скетча в формат, подходящий для загрузки на плату Arduino.
Дальше статус сменится на “Загрузка” (“Uploading”). В этот момент светодиоды на плате начнут мигать, так как начнется перенос скетча в микропроцессор.
В конце статус сменится на ”Загрузка завершена” (“Done uploading”). В сообщении, которое появится в текстовой строке отобразится информация о том, что загруженный скетч занимает 1,084 байта из 32,256 доступных.
Иногда при компиляции у Вас может возникнуть подобная ошибка:
Причин может быть несколько: Вы не подключили плату к компьютеру; Вы не установили необходимые драйвера; Вы выбрали некорректный серийный порт.
Если же загрузка прошла корректно, плата Arduino перезагрузится и “L” светодиод начнет мигать.
Пояснения к скетчу “Blink”
Ниже представлен код скетча “Blink”.
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Первое, на что стоит обратить внимание: в данном скетче множество “комментариев”. Обратите внимание, что комментарии не являются инструкцией по работе программы. Это исключительно пояснения отдельных функций и задач, которые выполняются на определенном этапе кода. Это не обязательная часть кода.
Все между символами /* и */ в верхней части скетча – это комментарии, в которых описаны задачи программы. Так же есть комментарии, которые ограничиваются одной строкой. Они начинаются с символов // и заканчиваются по умолчанию в конце строки.
Первая важная, по сути, часть данного кода это строка:
В комментариях над строкой указано, что мы присваиваем имя пину, к которому подключен светодиод. На большинстве плат Arduino это будет 13 пин. Дальше используется функция “Setup”.
Опять-таки, в комментариях указано, что функция срабатывает после нажатия кнопки “reset”. Также эта функция срабатывает, когда плата перезагрузится по каким-либо другим причинам.
Например, подача питания или после загрузки скетча.
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}
Каждый скетч Arduino обязан включать в себя функцию “setup” и часть, в которую вы можете добавлять собственные инструкции, заключенные между { }.
В нашем примере в функции присутствует только одна команда, в которой указано, что пин, который мы используем, настраивается на “вывод” (“Output”). Также обязательным для любого скетча является функция цикла “Loop”.
В отличие от функции “Setup ”, которая отрабатывает один раз после перезагрузки, функция “Loop” после окончания работы команд, вновь запустится.
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
В теле функции “Loop” светодиод включается (HIGH), данное значение задерживается на 1000 миллисекунд (1 секунда), светодиод отключается (LOW) и остается выключенным на 1 секунду, после чего цикл повторится.
Изменение частоты мигания светодиода
Для того, чтобы обеспечить более частое мигание светодиода, необходимо изменить параметр, указываемый в скобках ( ) в команде “delay”.
Как уже было указано, период задержки указывается в миллисекундах. То есть, для того, чтобы заставить светодиод мигать в два раза чаще, необходимо изменить значение с 1000 на 500. В результате, пауза между включением/выключением светодиода составит половину секунды и светодиод будет мигать быстрее.
Для проверки, не забудьте загрузить измененный скетч на плату Arduino.
Источник: http://arduino-diy.com/arduino-miganiye-vstroyennym-na-platu-svetodiodom
Рабочая программа по информатике и икт на тему: кружок Arduino
МКОУ «Батуринская средняя общеобразовательная школа
Шадринского района Курганской области»
«Робототехника на основе Arduino»
Составитель: Ершов А.А.
С. Батурино 2016
Пояснительная записка
В соответствии с требованиями ФГОС основного общего образования обучающийся должен владеть универсальными учебными действиями, способностью их использовать в учебной, познавательной и социальной практике, уметь самостоятельно планировать и осуществлять учебную деятельность, создавать, применять и преобразовывать знаки и символы, использовать ИКТ.
Технологии образовательной робототехники способствуют эффективному овладению обучающимися универсальными учебными действиями, так как объединяют разные способы деятельности при решении конкретной задачи.
Кружок «Робототехника на основе Arduino» предназначен для того, чтобы учащиеся имели представления о мире техники, устройстве конструкций, механизмов и машин, их месте в окружающем мире.
Реализация данного кружка позволяет стимулировать интерес и любознательность, развивать способности к решению проблемных ситуаций умению исследовать проблему, анализировать имеющиеся ресурсы, выдвигать идеи, планировать решения и реализовывать их, расширить технический и математический словари ученика. Кроме этого, помогает развитию коммуникативных навыков учащихся за счет активного взаимодействия детей в ходе групповой проектной деятельности.
Настоящая программа предназначена для учащихся 7 классов образовательных учреждений, которые впервые будут знакомиться с Arduino. Занятия проводятся 1 раз в неделю, рассчитанные на весь учебный год, 34 недели.
Конструируя и программируя дети помогают друг другу.
Робототехника — прикладная наука, занимающаяся разработкой автоматизированных технических систем. Робототехника опирается на электронику, механику и программирование. Для обучения учащихся, склонных к естественным наукам, технике или прикладным исследованиям, важно вовлечь их в такую учебно-познавательную деятельность и развить их способности в дальнейшем.
В отличие от LEGO роботов, которые собираются из блоков, робототехника на основе Arduino открывает больше возможностей, где можно использовать практически все что есть под руками.
На современном этапе в условиях введения ФГОС возникает необходимость в организации урочной и внеурочной деятельности, направленной на удовлетворение потребностей ребенка, которые способствуют реализации основных задач научно-технического прогресса.
Целью использования «Робототехника на основе Arduino» является овладение навыками технического конструирования, знакомство с элементами радио-конструирования, развитие мелкой моторики, изучение понятий конструкции и основных свойств (жесткости, прочности, устойчивости), навык взаимодействия в группе.
Дети работают с микросхемой Arduino UNO, L293D, и наборами датчиков. С их помощью школьник может запрограммировать робота – умную машинку на выполнение определенных функций.
Применение роботостроения в школе, позволяет существенно повысить мотивацию учащихся, организовать их творческую и исследовательскую работу. А также позволяет школьникам в форме познавательной игры узнать многие важные идеи и развивать необходимые в дальнейшей жизни навыки.
Цель: образование детей в сфере инновационных технологий на основе конструирования и программирования роботов Arduino, содействие развитию технического творчества, развитие инновационной деятельности в образовательных учреждениях.
Задачи:
- Стимулирование мотивации учащихся к получению знаний, помогать формировать творческую личность ребенка.
- Развитие интереса к технике, конструированию, программированию, высоким технологиям.
- Развитию конструкторских, инженерных и вычислительных навыков.
- Развитие мелкой моторики.
- Формирование умения достаточно самостоятельно решать технические задачи в процессе конструирования моделей.
Предполагаемые результаты реализации программы
Личностные, метапредметные и предметные
результаты освоения курса:
Личностными результатами изучения является формирование следующих умений:
- самостоятельно и творчески реализовывать собственные замыслы.
- повышение своего образовательного уровня и уровня готовности к продолжению обучения с использованием ИКТ.
- навыки взаимо – и самооценки, навыки рефлексии;
- сформированность представлений о мире профессий, связанных с робототехникой, и требованиях, предъявляемых различными востребованными профессиями, такими как инженер-механик, конструктор, архитектор, программист, инженер-конструктор по робототехнике;
Предметные образовательные результаты:
- Определять, различать и называть детали конструктора,
- Способность реализовывать модели средствами вычислительной техники;
- конструировать по условиям, заданным взрослым, по образцу, по чертежу, по заданной схеме и самостоятельно строить схему.
- Владение основами разработки алгоритмов и составления программ управления роботом;
- Умение проводить настройку и отладку конструкции робота.
Метапредметными результатами изучения является формирование следующих универсальных учебных действий (УУД):
Познавательные УУД:
- ориентироваться в своей системе знаний: отличать новое от уже известного.
- перерабатывать полученную информацию: делать выводы в результате совместной работы всего класса, сравнивать и группировать предметы и их образы;
- умение устанавливать взаимосвязь знаний по разным учебным предметам (математике, физике, природоведения, биологии, анатомии, информатике, технологии и др.) для решения прикладных учебных задач по Робототехнике.
Регулятивные УУД:
- уметь работать по предложенным инструкциям.
- умение излагать мысли в четкой логической последовательности, отстаивать свою точку зрения, анализировать ситуацию и самостоятельно находить ответы на вопросы путем логических рассуждений.
- определять и формулировать цель деятельности на занятии с помощью учителя;
Коммуникативные УУД:
- уметь работать в паре и в коллективе; уметь рассказывать о постройке.
- уметь работать над проектом в команде, эффективно распределять обязанности.
Содержание курса
Тема 1. Введение (1ч.)
Правила поведения при работе с микросхемами.
Тема 2. Основы радиоэлектроники (1ч.)
Понятие электрический ток, напряжение, сила тока, закон Ома, знакомство с мультиметром.
Тема 3. Схема. Условно – графическое изображение(1ч.)
Знакомство с радиоэлементами, изображениями на схеме.
Тема 4. Принципиальная электрическая схема. (1ч.)
Составление принципиальной электрической схемы, монтаж и отладка.
Тема 5. Электроприводы. Редукторы (1ч.)
Обзор робототехнических приводов. Знакомство с основными видами электродвигателей. Способы передачи движения. Понятие о редукторах.
Тема 6. Непрограммируемые роботы (3ч.)
Роботы на транзисторах. Знакомство с микросхемой L293D, L298N и ее возможностями.
Тема 7. Микроконтроллер (1ч.)
Знакомство с микроконтроллером Arduino
Тема 8. Интерфейс работы с Arduino (1ч.)
Среда разработки Arduino
Тема 9. Свет и звук. (2ч.)
Подключение светодиодов, семисегментного индикатора, ЖК дисплея и пьезоэлемента.
Тема 10. Управление (2ч.)
Подключение кнопок и джойстика.
Тема 11. Сервопривод (1ч.)
Изучение сервопривода. Подключение и программирование.
Тема 12. Датчики расстояния (3ч.)
Знакомство с датчиками измерения расстояния. Соединение датчиков расстояния и сервоприводов, поворот в определенную сторону.
Тема 13. Датчики и модули (3ч.)
Знакомство с датчиками температуры, влажности. Подключение Wi-Fi и Bluetooth модулей.
Тема 14. Драйвер двигателя.(2ч.)
Знакомство с драйвером двигателя.
Тема 15. Линейная программа (1ч.)
Сборка простой модели. Движение вперед назад.
Тема 16. Разветвляющаяся программа (2ч.)
Сборка модели, движущейся по линии.
Тема 17. Умный робот (2ч.)
Сборка модели с сервоприводом и ультразвуковым дальномером, объезжающим препятствия.
Тема 18. Проект «Мой робот»(4ч.)
Сборка собственной модели.
Тема 19. Демонстрация моделей(2ч.)
Тематическое планирование
| № | Название темы | Количество часов | Формаорганизации |
Источник: https://nsportal.ru/shkola/informatika-i-ikt/library/2017/02/01/kruzhok-arduino
Подключение адресной светодиодной ленты WS2812B к Arduino
Введение
Приветствую всех. Мы продолжаем знакомить Вас со светодиодными лентами. На этот раз мы рассмотрим адресную RGB светодиодную ленту WS2812B.
Лента основана на светодиодах WS2812B в корпусе LED 5050, куда в корпус производители поместили не только три встроенных светодиода (Красный, Зеленый, Синий), но и управляемый ШИМ драйвер, управляющий их яркостью.
Благодаря этому мы можем получить произвольный цвет, изменяя яркость встроенных светодиодов, а так же управлять отдельно взятым пикселем на ленте. Собственно, три встроенных разноцветных светодиода вместе с ШИМ драйвером и образуют светодиод WS2812B.
Немного запутывает, не правда ли? Светодиод, который содержит себе три разноцветных светодиода, но при этом сам – не светит, а светятся те три, что в него встроены. Поэтому мне проще называть его пикселем, нежели светодиодом. И далее, если я упоминаю пиксель – знайте, что это светодиод WS2812B.
На фото справа вы можете увидеть этот самый светодиод WS2812B, где большой черный прямоугольник это ШИМ драйвер, а вот три встроенных в него светодиода настолько малы, что их с трудом видно, и можно отследить только по золотым нитям, идущим от драйвера к трем разноцветным светодиодам.
Технические характеристики
Теперь давайте немного пройдемся по техническим характеристикам из datasheet который мне удалось раскопать в интернете.
- Светодиод WS2812B работает от напряжения 5В (±0.5).
- Ток ~20мА на один встроенный светодиод, то есть ~60мА на пиксель в целом.
- Рабочая температура от -20 до +80 ℃.
Остальное можете посмотреть самостоятельно в даташите.
Подключение
Подключается светодиодная лента довольно-таки просто, необходимо подать на +5V и GND, плюс (+) и минус (-) от 5В блока питания, а контакт DIN соединить с портом Arduino, как правило, по умолчанию используется 6-й порт Arduino, но вы вправе выбрать и любой другой свободный порт. Так же рекомендуется соединить земли Arduinoи блока питания, как нарисовано на рисунке ниже.
Будьте внимательны, лента на светодиодах WS2812B имеет направление, с одной стороны она имеет контакты DIN, +5V, GND, а с другой стороны DO, +5V, GND, подключать необходимо именно вход, то есть DIN, иначе лента не будет работать. Так же на ленте нарисованы стрелки, указывающие на направление.
Протокол
Теперь, когда мы разобрались, как подключить нашу ленту к Arduino, нам надо понять, как ею управлять, для этого в даташите есть описание протокола, который мы сейчас и рассмотрим.
Каждый светодиод WS2812B имеет один вход (DIN) и один выход (DO). Выход каждого светодиода подключается ко входу следующего. Подавать сигналы же надо на вход самого первого светодиода, таким образом, он запустит цепь, и данные будут поступать от первого ко второму, от второго к третьему и т. д.
Команды светодиодам передаются пачками по 24 бита (3 байта, один байт на каждый цвет, первым передается байт для зеленого, потом для красного, и заканчивает байт для синего светодиода. Порядок бит – от старшего к младшему). Перед каждой пачкой идет пауза в 50 мкс.
Пауза больше 100 мкс воспринимается как окончание передачи. Все биты, будь то 0 или 1, имеют фиксированное время 1.25 мкс. Бит 1 кодируется импульсом в 0.8 мкс, после чего идет пауза в 0.45 мкс. Бит 0 кодируется импульсом в 0.4 мкс, после чего идет пауза в 0.85 мкс.
Собственно, наглядная диаграмма на фото ниже. Так же допускаются небольшие погрешности в 0-150 нс на каждый фронт. Ну и следует учесть, что подобное необходимо повторить для каждого светодиода на ленте, после чего сделать паузу минимум в 100 мкс.
Потом можно повторить передачу.
Глядя на все эти цифры, становится ясно, что сделать все это, используя стандартные функции digitalWrite, delay и тому подобные – попросту невозможно, ввиду их долгой работы и неточности. Реализовать подобный протокол можно только использовав специальные библиотеки вроде CyberLib или написав собственную на чистом Си или, того хуже для нынешнего программиста, на Ассемблере.
Но не все так плохо, как кажется. Светодиоды WS2812B довольно таки популярны в Arduino сообществе, а это значит, что нам не придётся вдаваться в такие сложности, и достаточно выбрать одно из понравившихся решений.
Библиотеки
Поискав в интернете, вы найдете, как минимум, две большие библиотеки для работы со светодиодами WS2812B.
Под большими библиотеками я подразумеваю не количество функций и возможностей, хотя и это то же, а количество людей, участвовавших в их разработке.
Конечно, поискав, еще можно найти и другие библиотеки, разработанные отдельно взятыми ардуинщиками, но работающими не на всех микроконтроллерах Arduino и с большим количеством багов.
- Библиотека FastLED, разрабатывается Даниэлем Гарсиа и Марком Кригсманом. Имеет свой сайт, справочную систему и большое сообщество в ~5000 человек. Библиотека написана на чистом Си, без использования Wiring. FastLED поддерживает все виды Arduino (и не только), а так же умеет работать с кучей различных протоколов и интерфейсов. В том числе и протокол для управления лентами на светодиодах WS2812B.
- Библиотека Adafruit NeoPixel (Полное описание на нашем сайте), разрабатывается компанией Adafruit Industries. Предназначена для работы со светодиодными лентами и неопиксельными кольцами, продаваемыми в их интернет магазине. Библиотека написана на Си и Ассемблере с небольшим использованием Wiring. Эдакая солянка. Поддерживает все виды Arduino. Содержит меньший функционал по сравнению с FastLED, немного медленней, но имеет более компактный вид, только основное для работы.
Теперь давайте напишем наш излюбленный пример Blink, используя обе эти библиотеки, и затем сравним их.
Пример Blink используя ленту WS2812B (с 30 светодиодами) и библиотеку FastLED
// Подключаем библиотеку FastLED. #include “FastLED.h” // Указываем, какое количество пикселей у нашей ленты. #define LED_COUNT 30 // Указываем, к какому порту подключен вход ленты DIN. #define LED_PIN 6 // Создаем переменную strip для управления нашей лентой. CRGB strip[LED_COUNT]; void setup() { // Добавляем ленту.
FastLED.addLeds(strip, LED_COUNT); } void loop() { // Включаем все светодиоды. for (int i = 0; i < LED_COUNT; i++) { strip[i] = CRGB::Red; // Красный цвет. } // Передаем цвета ленте. FastLED.show(); // Ждем 500 мс. delay(500); // Выключаем все светодиоды.
for (int i = 0; i < LED_COUNT; i++) { strip[i] = CRGB::Black; // Черный цвет, т.е. выключено. } // Передаем цвета ленте. FastLED.show(); // Ждем 500 мс. delay(500); }Скетч использует 3758 байт (11%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 187 байт (9%) динамической памяти, оставляя 1861 байт для локальных переменных. Максимум: 2048 байт.
Пример Blink используя ленту WS2812B (с 30 светодиодами) и библиотеку Adafruit NeoPixel
// Подключаем библиотеку Adafruit NeoPixel. #include “Adafruit_NeoPixel.h” // Указываем, какое количество пикселей у нашей ленты. #define LED_COUNT 30 // Указываем, к какому порту подключен вход ленты DIN. #define LED_PIN 6 // Создаем переменную strip для управления нашей лентой.
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); void setup() { // Инициализируем ленту. strip.begin(); } void loop() { // Включаем все светодиоды. for (int i = 0; i < LED_COUNT; i++) { strip.setPixelColor(i, strip.Color(255, 0, 0)); // Красный цвет. } // Передаем цвета ленте. strip.show(); // Ждем 500 мс.
delay(500); // Выключаем все светодиоды. for (int i = 0; i < LED_COUNT; i++) { strip.setPixelColor(i, strip.Color(0, 0, 0)); // Черный цвет, т.е. выключено. } // Передаем цвета ленте. strip.show(); // Ждем 500 мс. delay(500); }Скетч использует 2592 байт (8%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 40 байт (1%) динамической памяти, оставляя 2008 байт для локальных переменных. Максимум: 2048 байт.
Подытожим
Как вы видите из скетчей выше, работать с обеими библиотеками довольно таки просто. Но библиотека FastLED занимает больше места в памяти Arduino, более того чем больше пикселей в вашей ленте тем больше памяти она зарезервирует для своей работы, а точнее 3 байта на каждый пиксель.
Таким образом подключить к Arduino можно не более 600 пикселей при использовании минимальной логики. По этому, мне больше приглянулась библиотека Adafruit NeoPixel. В ней только нужное для работы со светодиодными лентами и более рациональное использование памяти. Какую из этих библиотек использовать, решать, конечно, вам.
Обе они работают и со своею задачей справляются на 5+.
Ну а мы на этом закончим с обзором ленты. Далее мы сделаем на ее основе несколько проектов, для более наглядной демонстрации, но это уже буду отдельные статьи. Успехов вам и удачи. Оставляйте свои отзывы и комментарии.
Смотрите также
Источник: http://arduino.on.kg/podklyuchenie-adresnoy-svetodiodnoy-lenty-WS2812B-k-Arduino
Столик из RGB светодиодов на Arduino. Часть 1
В течении последнего года в процессе серфинга по интернету на тему Arduino, я находил достаточно много интересных проектов светодиодных столиков (RGB LED Coffee table).
Самые на мой взгляд удачные и не сложные в повторении решения, основываются на arduino производных платах типа colorduino и rainbowduino.
Данные платы заточены под цветные светодиодные матрицы с общим анодом, их можно приобрести на том же ebay. Вот например некоторые интересные проекты:
Светодиодный столик построенный на плате rainbowduino v 2.0.
Платами Rainbowduino можно управлять с помощью программы mtXcontrol
Огромный светодиодный стол, состоящий из 512 RGB светодиодов. Автор построил его на основе 8ми плат Rainbowduino v 3.
0 Подробнее вы можете почитать на его страничке.
Так же вы можете управлять платами rainbowduino (поддержка v 2.0 и 3.0) с помощью ПО PixelConroller
А здесь представлена работа платы colorduino из которой тоже получится замечательный столик.
Для того что бы управлять colorduino была модифицирована программа mtXcontrol. RGBcontrol по функционалу не чем не отличается, кроме нескольких дополнительных режимов.
Представленные выше проекты померкли в моих глазах, когда я случайным образом натолкнулся на команду разработчиков solderlab. Они разработали собственную плату на чипе Atmega 328P с применением 3х tlc5940 (отличные драйверы светодиодов, естественный цвет).
Каждая такая плата может управлять матрицей размером 16×8 и использует uart для взаимодействия друг с другом, что бы увеличить размерность всей матрицы. Данный от компьютера передаются на фиксированной скорости передачи данных 1 Мбит/с. В контроллере используется bootloader от Arduino.
Ребята так же представили бесплатное программное обеспечение Glediator, которое впечатлило меня своими возможностями и функционалом.
ПО Glediator. Я его успел протестировать в боевом режиме! Работает замечательно, то что нужно!
У них на сайте можно приобрести плату по цене 79 евро. Дороговато! Но для простых людей, которые могут и сами сделать подобное, есть подробная схема и исходник для Arduino IDE. На данный момент навыки в Eagle CAD позволили мне повторить схему и нарисовать печатную плату под ЛУТ.
Модель печатной платыПлата, сделанная с помощью ЛУТ
С компонентной базой пришлось немножко по колдовать Atmega328 и IRF7314 (mosfet транзистор) были заменены на более дешевые Atmega168PA-AU(работа устройства не пострадала, так как объем кода всего лишь 2 кб) и IRF7316.
В качестве основы для будущей светодиодной матрицы я выбрал довольно известный придиванный столик IKEA. Стоит он не дорого, а разбирается очень просто. Достаточно вскрыть верхнюю поверхность кухонным ножом и убрать бумажные перегородки. Внутренней площади, вполне достаточно, что бы разместить 2 платы и матрицу 16×16 из 256 RGB светодиодов!
«Выпотрошенный» столик IKEA. Полностью удалена верхняя часть, немного подпилены до высоты 15мм кубики с резьбой и шпильки ножек.Матрица из 3мм ПВХ-пластикаКрышка стола выполнена из молочного оргстекла с хорошой светопропускаемостью размером 548×548 мм
На текущий момент собрана 1/4 часть стола.
P.S. Продолжение следует. Жду доставки необходимых комплектующих…
Источник: http://lukjanow.ru/2013/01/rgb-led-coffee-table-part1/
Управление адресной лентой ws2812 с использованием библиотеки Adafruit NeoPixel. — Сообщество «Arduino для автомобиля» на DRIVE2
О чем это я и для кого?Я хочу рассказать как быстро и просто можно оживить ленту на базе “умных” светодиодов типа WS2811(12), SK6812, INK1003 и других без лишних затрат, имея только ардуино, библиотеку Adafruit NeoPixel, кусок ленты и час свободного времени, чтобы получить подобную занятную иллюминацию или что то еще в соответствии с вашей целью. Моя цель — не эта гирлянда или готовый скетч. Весь код в тексте и в прилагаемом скетче служит только для того, чтобы показать возможности сторонней библиотеки от компании Adafruit, накидан на скорую руку, и никак не является образцом для подражания или пособием по программированию. Он всего лишь работает с кусочком ленты и демонстрирует несложные эффекты. Вам не нужно ничего тупо повторять. Считайте это подробным справочником по нескольким функциям NeoPixel с примерами их использования в коде СИ. Посему просьба оставить мокрые тапки для своих котов)
Для кого обзор? Конечно для тех, кто только начинает знакомство со смарт-лентами и имеет представление о том, как работает ардуино и как пишется под него код.
ссылка на скетч из видео
Теперь поехали)Достаточно популярными “умные ленты” стали уже давно. Среди них существует множество китайских клонов, собранных как на обычных диодах RGB и внешними управляющими регистрами, так и “полноценные”, с использованием ws2812 со встроенным в корпус 5050 контроллером.
Принцип работы практически одинаков для всех лент и матриц с SPI (последовательным) интерфейсом. Это относится к WS2811(12), SK6812, INK1003 и другим подобным драйверам.
На вход первого контроллера ленты передается непрерывный поток данных, в каждом пакете которого содержится 3 или 4 (для RGBW пикселей)байта со значением цвета для каждого из 3 или 4 светодиодов в пикселе.
Контроллер первого пикселя “откусывает” себе первые 3(4) байта, устанавливает свой цвет в соответствии с содержимым, а остальной поток пропускает к следующим пикселям, где происходит аналогичное “откусывание” и дальнейшая передача “из рук в руки” до тех пор, пока в потоке не возникнет пауза в 50 мкс, означающая что пора принимать данные с начала)В зависимости от типа контроллера, тактовая частота может составлять 400 или 800 кГц. Это позволяет не видеть глазу переходных процессов при реализации достаточно сложных световых эффектов. В различных контроллерах может быть разной тактовая частота, разное кодирование 0 и 1 Lo-Hi уровнями и наоборот, разное следование цвета в пакете и другие мелочи, значительно усложняющие жизнь нормальным людям при выборе средств реализации задуманной елочной гирлянды или пересвета днища в 14-ке) Ленты могут иметь и 4 вывода — два питающих, один управляющий, и один тактируемый. В моем примере лента имеет три вывода — питание 12В и управление. Так же есть моменты, связанные с питанием ленты — это опять же напряжение — 5 или 12В и ток потребления на метр. Я использовал отдельный блок питания 12В. При этом нужно учитывать, что питание ленты и ардуино никак не должны между собой быть связаны, если у вас разные напряжения питания! Только по общему проводу для передачи данных. С ардуинки нужно подключить вывод GND к минусовому проводу ленты и управляющий пин 6 (или какой назначите) ко входу ленты D in. +12В подается на ленту от своего
источника питания, ардуинка питается от своего (либо от USB).
Капиталисты из Adafruit рекомендуют сигнальный провод подключать через резистор порядка нескольких сот Ом, а на саму ленту перед первым контроллером вешать по питанию электролит 1000-2000uF, но у меня все прекрасно работает и напрямую, и через килоОмный резистор при длине шлейфа около 0,5 метра и без каких либо кондеров на ленте.
Все страхи актуальны имхо при гораздо бОльших отрезках ленты, чем мой)С подключением в общем то ничего хитрого нет. Рассмотрим программную часть.
Для управления ws2812 настоящие true-программисты напишут true-код на ассемблере и прошьют true-контроллер от фирмы майкрочип, но для простых смертных выход тоже есть! Добрые дяди из Adafruit написали замечательную библиотеку, заточенную под ардуино, при помощи которой можно на простом cи из г.
на и костылей (как в моем случае) соорудить вполне себе работающий г.но код и не заботиться об организации интерфейса и не заглядывать в даташиты контроллеров лент. Об этом уже позаботились авторы библиотеки и нам не нужно ничего знать, кроме ее функций и конфигурирования двух строк в привычной среде.
Что еще следует понимать — каждый пиксель — это память. И она не бесконечна. Например ардуинка uno R3 потянет не более 500 пикселей.
С мегой можно развернуться и пошире)А пока хочу немного рассказать после пары дней экспериментов про использование возможностей библиотеки, назначение ее функций и конфигурирование в привязке к типу ленты и количества пикселей в ней.
Сам к ардуине подключал unoR3 и отрезок ленты с INK1003 всего на 6 пикселей (каждый из 3-х отдельных RGB диодов 5050?, бывает и такое в Китае). Но об этом немного позже, а сейчас начнем с самого начала — установки.Устанавливается библиотека просто — в программной среде для ардуино в меню “Скетч” выбираем “Подключить библиотеку” –> “Управлять библиотеками”.Откроется окно со списком библиотек, которые уже установлены. В форме поиска вводим “Adafruit NeoPixel”, находим, скачиваем и устанавливаем.
Теперь остается до функциии void setup()прописать заголовок библиотеки — #include , несколько строк конфигурации и можно начинать кодить)
Чтобы лучше понять, что мы получили, давайте посмотрим, что содержат файлы библиотеки)Каталог Adafruit_NeoPixel/examples/ — содержит несколько примеров использования библиотеки:RGBWstrandtest — не интересен, так как моя лента просто RGB)buttoncycler — демонстрирует переключение 3-х эффектов нажатием кнопкиsimple.ino показывает как покрасить ленту зеленымstrandtest.
ino — те же три эффекта, но без нажатия кнопокПримеры очень полезные и интересные, но лучше пойдем дальше и сделаем что то свое, пусть и не так красиво).Нужно условиться, что дальше по тексту под словом “пиксель” я подразумеваю три (или 4) разных светодиода в одном корпусе. Поэтому “красный цвет пикселя” и “красный цвет диода” — понятия совершенно разные.
Первый — это совокупность цветов. Второй — восьмибитная яркость отдельного красного светодиода из этой совокупности — от 0 до 255.Идем дальше, файл — Adafruit_NeoPixel.cpp
Содержит функции, с которыми мы будем работать. Желающие ознакомиться с оригинальным (на английский езыке) руководством можно здесь — learn.adafruit.
com/adafru…?view=all#arduino-library , а для ленивых продолжу излагать своим языком как умею)
Кстати — по ссылке много интересных проектов для ардуины с описанием и кодом не только для ленточных изделий)
Первая чуть ли не самая важная функция — strip.setPixelColor(n, red, green, blue, white); Она устанавливает цвет каждого диода (красного-зеленого-синего) в n-пикселе в соответствии с переданными функции параметрами.
Т.е. n здесь — номер пикселя в ленте, следующие за ним три или четыре параметра — цвета диодов от 0 до 255. Если используем ленту с дополнительным белым диодом в пикселе — мы задаем 4 параметра (32 бита информации, по байту на цвет) или 3 (24 бита информации), как в моем случае.
Например, strip.setPixelColor(45, 255, 0, 0); задаст красный цвет 46-му пикселю в ленте (нужно помнить, что в программе первый пиксель — это “0”).
Альтернативно — strip.setPixelColor(n, color); Здесь n так же — номер пикселя в ленте, но уже 32 битный цвет, например — uint32_t magenta = strip.Color(255, 0, 255);
Еще одна функция strip.Color(255, 0, 255); — как раз конвертирует в одно 32 битное значение три разных параметра цвета для отдельных диодов — RGB. В этом примере (255, 0, 255)- одинаковые по яркости красный и синий диоды. Теперь если мы вызовем strip.setPixelColor с 32 битным параметром magenta, которому ранее присвоили значение функцией strip.Color, мы зададим 46 пикселю этот цвет одним значением: strip.setPixelColor(45, magenta); Итого — всего два параметра) Просто вместо трех восьми битных имеем один 32 битный с местом под значение четвертого диода, даже если его в пикселях ленты нет.
Но как и сколько бы мы не задавали цвет, с лентой ничего не произойдет. Передачу каждого пакета данных с заданными цветами каждого диода в каждом пикселе нужно инициализировать. Поэтому ваш код должен быть как можно эффективнее, ибо для вывода сложных эффектов нужна максимальная частота обновления пикселей, а выполнение вашего кода тоже требует процессорного времени. Допустим, вы назначили каждому пикселю набор цветов. Пора вызывать функцию поважнее “сет_пиксел_колора” — strip.show(); Она вызывается без параметров и обновляет все пиксели ленты, один за другим с частотой 400 или 800 кГц). Теперь изменения можно увидеть). Эта же функция является обязательной в разделе void setup(). Перед ней в этом разделе так же обязан находится вызов функции strip.begin(), т.е. примерно так:
void setup(){strip.begin();strip.show(); // Здесь эта функция ничего не “засветит, а наоборот -принудительно выключит все пиксели.
}
Продолжим по функциям, нужным для комфортного кодинга) Раз уж есть функция, “запихивающая” три байта в одно значение, логичным будет и обратный процесс. Но увы, его нет.
Есть только возможность средствами библиотеки извлечь тот же 32-битный цвет из конкретного пикселя. Занимается этим делом uint32_t color = strip.getPixelColor(11); Хотя при необходимости и желании можно уже “вручную” вытащить нужные цвета и определить каждый по своему байту)
Например так —
//—————————————long i = strip.
getPixelColor(15); //Получаем цвет 16-го пикселяuint8_t r = (uint8_t)((i >> 16) & 0xff), //Первый байт — красный цветuint8_t g = (uint8_t)((i >> 8) & 0xff), //Второй байт — зеленый цветuint8_t b = (uint8_t)(i & 0xff); //Третий байт — синий цветstrip.setPixelColor(16, r, g, b); //Назначаем полученные значения отдельным диодам 17-го пикселя
//—————————————
Это желательно оформить в свою отдельную функцию и для своего же удобства и упрощения кода. Хотя и необязательно.
Здесь важно понимать один момент — несмотря на название getPixelColor, функция не выполняет физического обращения к ленте для получения цвета заданного вами номера пикселя.
Это невозможно в SPI, работающего по принципу ниппеля — только “туда”. Но при первом же вызове setPixelColor в массив pixels[n] для значений пикселей записываются по порядку все устанавливаемые цвета всех диодов в 32-битном значении и хранятся там до следующего вызова этой же функции, которая опять обновит и ленту, и массив.
В промежутке можно извлечь из этого массива 32-битный цвет из нужного пикселя с помощью getPixelColor.
Это значит, что вы можете в любой момент в любом месте кода выполнять любые действия, не связанные с управлением лентой, и затем вернуться к установленным и включенным хоть 5 минут назад цветам в совсем другой функции и продолжить с ними работать “с того же места”.
Можно легко задать (установить) или изменить полученный 32-битный цвет в HEX формате. В качестве аргумента мы можем передать параметр цвета пикселя как 0xFF9C00 и функция это так же переварит.
Здесь то же самое, только FF — это красный диод с диапазоном значений от 0x00 до 0xFF, 9C — зеленый, и 00 — синий.Аналогично “вытаскиванию” восьмибитных десятичных значений каждого цвета мы можем побайтно изменить исходную величину.
Для этого я набросал небольшую функцию, которая изменяет HEX представление цвета SummColor на передаваемые значения RGB —
HEX_R, HEX_G, HEX_B.
uint32_t HEX_Math(uint32_t SummColor, uint32_t HEX_R, uint32_t HEX_G, uint32_t HEX_B){SummColor+=((HEX_R
Источник: https://www.drive2.ru/c/459471616670183295/
Загрузка...
