Casquillo de burro (2 / 4 paso)

Paso 2: El código

basado en ciclo plasma de Color
Versión 0.1 - 08 de julio de 2009
Copyright (c) 2009 Ben Combee. Todos los derechos reservados.
Copyright (c) 2009 Ken Corey. Todos los derechos reservados.
Copyright (c) 2008 Windell H. Oskay. Todos los derechos reservados.
Copyright (c) 2011 Sam C. Lin todos los derechos reservados

Esta demo es software libre; Usted puede redistribuirlo y/o
modificar bajo los términos de la GNU menor General pública
Licencia publicada por la Free Software Foundation; cualquiera de los dos
versión 2.1 de la licencia o (a su opción) cualquier versión posterior.

Esta demo se distribuye con la esperanza de que sea útil,
pero sin ninguna garantía; ni siquiera la garantía implícita de
COMERCIABILIDAD o aptitud para un propósito PARTICULAR. Ver la GNU
Lesser General Public License para más detalles.

Usted debe han recibido una copia de la GNU menor General pública
Licencia junto con esta biblioteca; Si no, escriba a la Free Software
Foundation, Inc., 51 Franklin St, quinto piso, Boston, MA 02110-1301 USA
*/

#include

typedef struct
{
unsigned char r;
unsigned char g;
unsigned char b;
} ColorRGB;

un color con 3 componentes: h, s y v
typedef struct
{
unsigned char h;
unsigned char s;
unsigned char v;
} ColorHSV;

plasma de unsigned char [ColorduinoScreenWidth] [ColorduinoScreenHeight];
largo paletteShift;

Convierte un color HSV en RGB
void HSVtoRGB (void * vRGB, void * vHSV)
{
Float r, g, b, h, s, v; Esta función trabaja con los flotadores entre 0 y 1
Float f, p, q, t;
int i;
ColorRGB * colorRGB =(ColorRGB *) vRGB;
ColorHSV * colorHSV =(ColorHSV *) vHSV;

h = (float) (colorHSV -> h/256.0);
s = (float) (colorHSV -> s/256.0);
v = (float) (colorHSV -> v/256.0);

Si saturación es 0, el color es un tono de gris
if(s == 0.0) {}
b = v;
g = b;
r = g;
}
Si saturación > 0, cálculos más complejos son necesarios
otra cosa
{
h * = 6.0; para dar color a un número entre 0 y 6, mejor para los cálculos
i = (int)(floor(h)); por ejemplo 2.7 se convierte en 2 y 3.01 se convierte en 3 o 4 4.9999
f = h - i; parte fraccionaria //the de h

p = (float) (v * (1,0 - s));
q = (float) (v * (1.0 - (s * f)));
t = (float) (v * (1.0 - (s * (1,0 - f)));

Switch(i)
{
caso 0: r = v; g = t; b = p; rotura;
caso 1: r = q; g = v; b = p; rotura;
caso 2: r = p; g = v; b = t; rotura;
caso 3: r = p; g = q; b = v; rotura;
caso 4: r = t; g = p; b = v; rotura;
caso 5: r = v; g = p; b = q; rotura;
por defecto: r = g = b = 0; rotura;
}
}
colorRGB -> r = (int)(r * 255.0);
colorRGB -> g = (int)(g * 255.0);
colorRGB -> b = (int)(b * 255.0);
}

flotador
Dist (flotador float a, float b, float c, d).
{
volver sqrt((c-a)*(c-a)+(d-b)*(d-b));
}

vacío
plasma_morph()
{
unsigned char x, y;
Float valor;
ColorRGB colorRGB;
ColorHSV de ColorHSV;

para (y = 0; y < ColorduinoScreenHeight; y ++)
para (x = 0; x < ColorduinoScreenWidth; x ++) {}
{
valor = pecado (dist (x + paletteShift, y, 128.0, 128.0) / 8.0)
+ pecado (dist (x, y, 64,0, 64,0) / 8.0)
+ pecado (dist (x, y + paletteShift/7, 192.0, 64) / 7.0)
+ pecado (dist (x, y, 192.0, 100.0) / 8.0);
colorHSV.h= (unsigned char)((value) * 128) & 0xff;
colorHSV.s=255;
colorHSV.v=255;
HSVtoRGB (colorRGB & colorHSV);

Colorduino.SetPixel (x, y, colorRGB.r, colorRGB.g, colorRGB.b);
}
}
paletteShift ++;

Colorduino.FlipPage(); intercambio de buffers de pantalla para mostrarlo
}

/********************************************************
Nombre: ColorFill
Función: Rellenar el marco con un color
Parámetro: R: el valor de rojo. Gama: rojo 0 ~ 255
G: el valor verde. Gama: rojo 0 ~ 255
B: el valor de azul. Gama: rojo 0 ~ 255
********************************************************/
ColorFill vacío (unsigned char I, G de unsigned char, unsigned char B)
{
PixelRGB * p = Colorduino.GetPixel(0,0);
para (unsigned char y = 0; y para (unsigned char x = 0; x p -> r = R;
p -> g = G;
p -> b = B;
p ++;
}
}

Colorduino.FlipPage();
}

void setup()
{
Colorduino.Init(); inicializar la Junta

compensar las diferencias de intensidad relativa de brillo R/G/B
matriz de valores base 6 bits para RGB (0 ~ 63)
whiteBalVal [0] = rojo
whiteBalVal [1] = verde
whiteBalVal [2] = azul
unsigned char whiteBalVal [3] = {36,63,63}; para LEDSEE 6x6cm redondo matriz
Colorduino.SetWhiteBal(whiteBalVal);

comenzar con morphing de plasma, pero permiten ir colorear ciclismo si lo desea.
paletteShift = 128000;
unsigned char bcolor;

generar el plasma una vez
para (unsigned char y = 0; y < ColorduinoScreenHeight; y ++)
para (unsigned char x = 0; x < ColorduinoScreenWidth; x ++)
{
el buffer del plasma es una suma de senos
bcolor = (unsigned char)
(
128.0 + (128.0 * pecado (x * 8.0/16.0))
+ 128.0 + (128.0 * pecado (y * 8.0/16.0))
) / 2;
plasma [x] [y] = bcolor;
}

para ajustar el balance de blancos puede descomentar esta línea
y comente la plasma_morph() en el loop()
y luego experimentar con whiteBalVal arriba
ColorFill(255,255,255);
}

void loop()
{
plasma_morph();
}