Исчезает ли Arduino RGB LED от одного цвета к другому?

Действительно возможно исчезать между различными цветами. То, что я обычно пропускаю в книгах и коде Arduino в сети, так это то, что можно писать классы C ++ в Arduino IDE. Поэтому я собираюсь показать пример, который исчезает между цветами, используя классы C ++.

Проблема, которая должна быть решена, заключается в том, какие выводы должны быть выполнены аналоговым письмом, потому что не все контакты способны к широтно-импульсной модуляции (PWM). На устройстве Arduino контакты, поддерживающие ШИМ, обозначены тильдой ‘~’. Arduino UNO имеет цифровые контакты ~ 3, ~ 5, ~ 6, ~ 9, ~ 10 и ~ 11. И большинство Arduino используют эти контакты для ШИМ, но проверьте ваше устройство, чтобы быть уверенным. Вы можете создать ШИМ на обычных цифровых выводах, включив светодиод на 1 мс и на 1 мс, это имитирует 50% мощности светодиода. Или включите его на 3 мс, и на 1 мс это имитирует 75% мощности.

Чтобы погас светодиод, вам нужно уменьшить / увеличить значение ШИМ и немного подождать. Вам придется немного подождать, потому что в противном случае arduino будет пытаться угасать / затухать светодиодами тысячи раз в секунду, и вы не увидите эффекта затухания, хотя, вероятно, он есть. Итак, вы ищете способ постепенно уменьшить / увеличить второй параметр до analogWrite( ) для трех светодиодов; Для более подробного объяснения см., Например, главу 7 Arduino Cookbook. В любом случае, эта книга хорошо читается фанатами Arduino!

Поэтому я адаптировал код из OP, чтобы он содержал класс ‘rgb_color’, который более или менее просто является контейнером для значений красного, зеленого и синего. Но что более важно, это класс фейдеров. Когда создается экземпляр фейдера, правильные выводы должны быть в конструкторе красного, зеленого и синего соответственно. Чем фейдер содержит функцию-член void fade( const rgb_color& const rgb_color&) который будет делать затухание между входным и выходным цветом. По умолчанию функция принимает 256 шагов по 10 мс от цвета ввода до цвета вывода. (обратите внимание, здесь из-за целочисленных делений это не означает, что каждый шаг 1/256-й, но перцептивно вы этого не заметите).

/*
* LedBrightness sketch
* controls the brightness of LEDs on "analog" (PWM) output ports.
*/

class rgb_color {

private:
int my_r;
int my_g;
int my_b;
public:
rgb_color (int red, int green, int blue)
:
my_r(red),
my_g(green),
my_b(blue)
{
}

int r() const {return my_r;}
int b() const {return my_b;}
int g() const {return my_g;}
};

/*instances of fader can fade between two colors*/
class fader {

private:
int r_pin;
int g_pin;
int b_pin;

public:
/* construct the fader for the pins to manipulate.
* make sure these are pins that support Pulse
* width modulation (PWM), these are the digital pins
* denoted with a tilde(~) common are ~3, ~5, ~6, ~9, ~10
* and ~11 but check this on your type of arduino.
*/
fader( int red_pin, int green_pin, int blue_pin)
:
r_pin(red_pin),
g_pin(green_pin),
b_pin(blue_pin)
{
}

/*fade from rgb_in to rgb_out*/
void fade( const rgb_color& in,
const rgb_color& out,
unsigned n_steps = 256,  //default take 256 steps
unsigned time    = 10)   //wait 10 ms per step
{
int red_diff   = out.r() - in.r();
int green_diff = out.g() - in.g();
int blue_diff  = out.b() - in.b();
for ( unsigned i = 0; i < n_steps; ++i){
/* output is the color that is actually written to the pins
* and output nicely fades from in to out.
*/
rgb_color output ( in.r() + i * red_diff / n_steps,
in.g() + i * green_diff / n_steps,
in.b() + i * blue_diff/ n_steps);
/*put the analog pins to the proper output.*/
analogWrite( r_pin, output.r() );
analogWrite( g_pin, output.g() );
analogWrite( b_pin, output.b() );
delay(time);
}
}

};

void setup()
{
//pins driven by analogWrite do not need to be declared as outputs
}

void loop()
{
fader f (3, 5, 6); //note OP uses 9 10 and 11
/*colors*/
rgb_color yellow( 250, 105,   0 );
rgb_color orange( 250,  40,   0 );
rgb_color red   ( 255,   0,   0 );
rgb_color blue  (  10,  10, 255 );
rgb_color pink  ( 255,   0, 100 );
rgb_color purple( 200,   0, 255 );
rgb_color green (   0, 255,   0 );
rgb_color white ( 255, 255, 255 );

/*fade colors*/
f.fade( white, yellow);
f.fade( yellow, orange);
f.fade( orange, red);
f.fade( red, blue);
f.fade( blue, pink);
f.fade( pink, purple);
f.fade( purple, green);
f.fade( green, white);
}

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

Например, работа в HSL цветовое пространство, сохраняйте постоянными S и L (скажем, полностью насыщенный и яркий цвет), а затем «плавно» H по кругу — вы перейдете от красного к зеленому, синему и обратно к красному. Преобразуйте обратно в RGB и затем используйте эти значения для ваших светодиодных накопителей. Я использовал эту технику для Приложение «Лампа настроения», и другие код для преобразования цветового пространства можно найти на SO.

Это, наверное, то, что вы ищете. Всякий раз, когда мы хотим сместить цвет по спектру и перемещать цвета круговым и плавным движением, мы действительно смещаем свет с использованием HUE в цветовом пространстве HSI / HSV (Hue, Saturation, Intensity / Value).

Возьмите, если хотите, эту цифру:

Мы добавим значение от 0 до 360 для оттенка, потому что оттенок имеет 360 градусов цвета.
Значение 0,00 — 1,00 для насыщения и значение 0,00 -1,00 для интенсивности / значения

Вот моя схема на MEGA 2560:

Вот видео с этим кодом:

<iframe width="560" height="315" src="https://www.youtube.com/embed/gGG-GndSKi0" frameborder="0" allowfullscreen></iframe>

struct Color
{
unsigned char r;
unsigned char g;
unsigned char b;
};

// the old color will be modified, hence it is not given as reference
void fade(Color old, const Color& newColor)
{
// get the direction of increment first (count up or down)
// each of the inc_x will be either 1 or -1
char inc_r = (newColor.r - old.r)/abs(newColor.r-old.r); // note, that the right hand side will be sign extended to int according to the standard.
char inc_g = (newColor.g - old.g)/abs(newColor.g-old.g);
char inc_b = (newColor.g - old.g)/abs(newColor.g-old.g);

fadeOneColor(old.r, newColor.r, inc_r, old);
fadeOneColor(old.g, newColor.g, inc_g, old);
fadeOneColor(old.b, newColor.b, inc_b, old);
}

void fadeOneColor( unsigned char& col_old,
const unsigned char& col_new,
const char inc,
Color& col)
{
while(col_old != col_new)
{
col_old += inc;
SetColor(col);
delay(20);
}
}

uint32_t fadeColor(uint32_t const x, uint32_t const y, uint8_t const fade)
{
// boundary cases don't work with bitwise stuff below
if (fade == 0)
{
return x;
}
else if (fade == 255)
{
return y;
}

uint16_t const invFadeMod = (255 - fade) + 1;
uint16_t const fadeMod = fade + 1;
// overflows below to give right result in significant byte
uint8_t const xx[3] // r g b
{
static_cast<uint8_t>((uint8_t(x >> 16) * invFadeMod) >> 8),
static_cast<uint8_t>((uint8_t(x >> 8) * invFadeMod) >> 8),
static_cast<uint8_t>((uint8_t(x >> 0) * invFadeMod) >> 8),
};
uint8_t const yy[3] // r g b
{
static_cast<uint8_t>((uint8_t(y >> 16) * fadeMod) >> 8),
static_cast<uint8_t>((uint8_t(y >> 8)* fadeMod) >> 8),
static_cast<uint8_t>((uint8_t(y >> 0)* fadeMod) >> 8),
};
return ((uint32_t)(xx[0] + yy[0]) << 16) | ((uint32_t)(xx[1] + yy[1]) <<  8) | (xx[2] + yy[2]);
}