Created
September 9, 2021 10:41
-
-
Save map7/1e7f17f61889dd26c1162add83468ab4 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
ColorduinoPlasma - Plasma demo using Colorduino Library for Arduino | |
Copyright (c) 2011 Sam C. Lin lincomatic@hotmail.com ALL RIGHTS RESERVED | |
based on Color cycling plasma | |
Version 0.1 - 8 July 2009 | |
Copyright (c) 2009 Ben Combee. All right reserved. | |
Copyright (c) 2009 Ken Corey. All right reserved. | |
Copyright (c) 2008 Windell H. Oskay. All right reserved. | |
Copyright (c) 2011 Sam C. Lin All Rights Reserved | |
This demo is free software; you can redistribute it and/or | |
modify it under the terms of the GNU Lesser General Public | |
License as published by the Free Software Foundation; either | |
version 2.1 of the License, or (at your option) any later version. | |
This demo is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
Lesser General Public License for more details. | |
You should have received a copy of the GNU Lesser General Public | |
License along with this library; if not, write to the Free Software | |
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
*/ | |
#include <Colorduino.h> | |
// To show off our hardware PWM LED driver (capable of displaying 16M colors), | |
// we will add gamma correction to show more accurate colors, and we will | |
// see better color transition. | |
#include "gamma8.h" | |
typedef struct | |
{ | |
unsigned char r; | |
unsigned char g; | |
unsigned char b; | |
} ColorRGB; | |
//a color with 3 components: h, s and v | |
typedef struct | |
{ | |
unsigned char h; | |
unsigned char s; | |
unsigned char v; | |
} ColorHSV; | |
// increase the scaling of the plasma to see more details of the color transition. | |
const float PlasmaScaling = 10.0; | |
unsigned char plasma[ColorduinoScreenWidth][ColorduinoScreenHeight]; | |
long paletteShift; | |
//Converts an HSV color to RGB color | |
void HSVtoRGB(void *vRGB, void *vHSV) | |
{ | |
float r, g, b, h, s, v; //this function works with floats between 0 and 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); | |
//if saturation is 0, the color is a shade of grey | |
if(s == 0.0) { | |
b = v; | |
g = b; | |
r = g; | |
} | |
//if saturation > 0, more complex calculations are needed | |
else | |
{ | |
h *= 6.0; //to bring hue to a number between 0 and 6, better for the calculations | |
i = (int)(floor(h)); //e.g. 2.7 becomes 2 and 3.01 becomes 3 or 4.9999 becomes 4 | |
f = h - i;//the fractional part of 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) | |
{ | |
case 0: r=v; g=t; b=p; break; | |
case 1: r=q; g=v; b=p; break; | |
case 2: r=p; g=v; b=t; break; | |
case 3: r=p; g=q; b=v; break; | |
case 4: r=t; g=p; b=v; break; | |
case 5: r=v; g=p; b=q; break; | |
default: r = g = b = 0; break; | |
} | |
} | |
colorRGB->r = (int)(r * 255.0); | |
colorRGB->g = (int)(g * 255.0); | |
colorRGB->b = (int)(b * 255.0); | |
// gamma correction | |
colorRGB->r = pgm_read_byte(&gamma8[colorRGB->r]); | |
colorRGB->g = pgm_read_byte(&gamma8[colorRGB->g]); | |
colorRGB->b = pgm_read_byte(&gamma8[colorRGB->b]); | |
} | |
float | |
dist(float a, float b, float c, float d) | |
{ | |
return sqrt((c-a)*(c-a)+(d-b)*(d-b)); | |
} | |
void | |
plasma_morph() | |
{ | |
unsigned char x,y; | |
float value; | |
ColorRGB colorRGB; | |
ColorHSV colorHSV; | |
for(y = 0; y < ColorduinoScreenHeight; y++) | |
for(x = 0; x < ColorduinoScreenWidth; x++) { | |
{ | |
value = sin((x + paletteShift) / PlasmaScaling) | |
+ sin(dist(x, y, 64.0, 64.0) / PlasmaScaling) | |
+ sin((y + paletteShift / 7.0) / PlasmaScaling) | |
+ sin(dist(x, y, 192.0, 100.0) / PlasmaScaling); | |
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(); // swap screen buffers to show it | |
} | |
/******************************************************** | |
Name: ColorFill | |
Function: Fill the frame with a color | |
Parameter:R: the value of RED. Range:RED 0~255 | |
G: the value of GREEN. Range:RED 0~255 | |
B: the value of BLUE. Range:RED 0~255 | |
********************************************************/ | |
void ColorFill(unsigned char R,unsigned char G,unsigned char B) | |
{ | |
PixelRGB *p = Colorduino.GetPixel(0,0); | |
for (unsigned char y=0;y<ColorduinoScreenWidth;y++) { | |
for(unsigned char x=0;x<ColorduinoScreenHeight;x++) { | |
p->r = R; | |
p->g = G; | |
p->b = B; | |
p++; | |
} | |
} | |
Colorduino.FlipPage(); | |
} | |
void setup() | |
{ | |
Colorduino.Init(); // initialize the board | |
// compensate for relative intensity differences in R/G/B brightness | |
// array of 6-bit base values for RGB (0~63) | |
// whiteBalVal[0]=red | |
// whiteBalVal[1]=green | |
// whiteBalVal[2]=blue | |
unsigned char whiteBalVal[3] = {36,63,63}; // for LEDSEE 6x6cm round matrix | |
Colorduino.SetWhiteBal(whiteBalVal); | |
// start with morphing plasma, but allow going to color cycling if desired. | |
paletteShift=128000; | |
unsigned char bcolor; | |
//generate the plasma once | |
for(unsigned char y = 0; y < ColorduinoScreenHeight; y++) | |
for(unsigned char x = 0; x < ColorduinoScreenWidth; x++) | |
{ | |
//the plasma buffer is a sum of sines | |
bcolor = (unsigned char) | |
( | |
128.0 + (128.0 * sin(x*8.0 / 16.0)) | |
+ 128.0 + (128.0 * sin(y*8.0 / 16.0)) | |
) / 2; | |
plasma[x][y] = bcolor; | |
} | |
// to adjust white balance you can uncomment this line | |
// and comment out the plasma_morph() in loop() | |
// and then experiment with whiteBalVal above | |
// ColorFill(255,255,255); | |
} | |
void loop() | |
{ | |
plasma_morph(); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment