added plasma demo to examples

michaelkamprath · michaelkamprath · commit 95a53a9ddbe8 · 2017-12-23T19:55:30.000-08:00
Added a Plasma demo to the examples set. Fixed a bug in the new
color management and added a library specific fmod implementation
to work around a bug in the ESP8266 standard libraries.
diff --git a/examples/plasma-10x10/plasma-10x10.ino b/examples/plasma-10x10/plasma-10x10.ino
@@ -0,0 +1,100 @@
+/* 
+ *  Plasma
+ *    
+ *  This is a demonstration of the plasma algorithm displayed on an RGB LED matrix. 
+ *  The COLOR_SCHEME global variable allows you to easily change between some pre-made
+ *  color schemes. Using the patterm of the demonstration color schemes, it should be 
+ *  easy to add others.
+ *  
+ *  The algorithm for this demo was sourced from here:
+ *  
+ *    https://www.bidouille.org/prog/plasma
+ * 
+ */
+#include <RGBLEDMatrix.h>
+#include <RGBColor.h>
+#include <RGBImage.h>
+
+/* Color Schemes
+ *  
+ *  1 - Full rainbow gradients in RGB
+ *  2 - Red, Orange, white gradients
+ *  3 - gray scale
+ * 
+ */
+const int COLOR_SCHEME = 1;
+
+const float SPACE_STRETCH_FACTOR = 5.0;
+const float TIME_DILATION = 5.0;
+
+RGBLEDMatrix leds(10,10);
+
+int mapSineToRange( float sineValue, int rangeMax ) {
+  return rangeMax*(sineValue+1.0)/2.0;
+}
+void drawPlasma( unsigned long counter ) {
+  float utime = float(counter)/TIME_DILATION;
+  
+  leds.startDrawing();
+  for (int col = 0; col < leds.columns(); col++ ) {
+    float x = ((float)col/((float)leds.columns()*SPACE_STRETCH_FACTOR)) - 0.5;
+
+    for (int row = 0; row < leds.rows(); row++ ) {
+      float y = ((float)row/((float)leds.rows()*SPACE_STRETCH_FACTOR)) - 0.5;
+
+      float v1 = sin(x*10.0+utime);
+      float v2 = sin(10.0*(x*sin(utime/2.0) + y*cos(utime/3.0)) + utime);
+      
+      float cx = x + 0.5*sin(utime/5.0);
+      float cy = y + 0.5*cos(utime/3.0);
+      float v3 = sin( sqrt(100.0*(cx*cx + cy*cy) + 1.0) + utime );
+      
+      float v = v1+v2+v3;
+
+      int r, g, b;
+      switch (COLOR_SCHEME) {
+        default:
+        case 1:
+          r = mapSineToRange(sin(v*PI), 255);
+          g = mapSineToRange(sin(v*PI + 2.0*PI/3.0), 255);
+          b = mapSineToRange(sin(v*PI + 4.0*PI/3.0), 255);
+          break;
+        case 2:
+          r = 255;
+          g = mapSineToRange(cos(v*PI), 255);
+          b = mapSineToRange(sin(v*PI), 255);
+          break;
+        case 3:
+          r = g = b = mapSineToRange(sin(v*5.0*PI), 255);
+          break;
+      }
+
+      RGBColorType color = RGBColor::fromRGB(r, g, b);
+                              
+      leds.image().pixel(row, col) = color;
+    }
+  }
+  leds.stopDrawing();
+}
+
+void setup() {
+  leds.setup();
+  drawPlasma(0);
+  leds.startScanning();
+}
+
+unsigned long loopCounter = 0;
+unsigned long timeCount = 0;
+
+const unsigned long loopMod = 2000;
+
+void loop() {
+  leds.loop();
+  loopCounter++;
+
+  if (loopCounter == loopMod) {
+    timeCount++;
+    drawPlasma(timeCount);
+    loopCounter = 0;
+  }
+}
diff --git a/examples/plasma-8x8/plasma-8x8.ino b/examples/plasma-8x8/plasma-8x8.ino
@@ -0,0 +1,100 @@
+/* 
+ *  Plasma
+ *    
+ *  This is a demonstration of the plasma algorithm displayed on an RGB LED matrix. 
+ *  The COLOR_SCHEME global variable allows you to easily change between some pre-made
+ *  color schemes. Using the patterm of the demonstration color schemes, it should be 
+ *  easy to add others.
+ *  
+ *  The algorithm for this demo was sourced from here:
+ *  
+ *    https://www.bidouille.org/prog/plasma
+ * 
+ */
+#include <RGBLEDMatrix.h>
+#include <RGBColor.h>
+#include <RGBImage.h>
+
+/* Color Schemes
+ *  
+ *  1 - Full rainbow gradients in RGB
+ *  2 - Red, Orange, white gradients
+ *  3 - gray scale
+ * 
+ */
+const int COLOR_SCHEME = 1;
+
+const float SPACE_STRETCH_FACTOR = 4.0;
+const float TIME_DILATION = 5.0;
+
+RGBLEDMatrix leds(8,8);
+
+int mapSineToRange( float sineValue, int rangeMax ) {
+  return rangeMax*(sineValue+1.0)/2.0;
+}
+void drawPlasma( unsigned long counter ) {
+  float utime = float(counter)/TIME_DILATION;
+  
+  leds.startDrawing();
+  for (int col = 0; col < leds.columns(); col++ ) {
+    float x = ((float)col/((float)leds.columns()*SPACE_STRETCH_FACTOR)) - 0.5;
+
+    for (int row = 0; row < leds.rows(); row++ ) {
+      float y = ((float)row/((float)leds.rows()*SPACE_STRETCH_FACTOR)) - 0.5;
+
+      float v1 = sin(x*10.0+utime);
+      float v2 = sin(10.0*(x*sin(utime/2.0) + y*cos(utime/3.0)) + utime);
+      
+      float cx = x + 0.5*sin(utime/5.0);
+      float cy = y + 0.5*cos(utime/3.0);
+      float v3 = sin( sqrt(100.0*(cx*cx + cy*cy) + 1.0) + utime );
+      
+      float v = v1+v2+v3;
+
+      int r, g, b;
+      switch (COLOR_SCHEME) {
+        default:
+        case 1:
+          r = mapSineToRange(sin(v*PI), 255);
+          g = mapSineToRange(sin(v*PI + 2.0*PI/3.0), 255);
+          b = mapSineToRange(sin(v*PI + 4.0*PI/3.0), 255);
+          break;
+        case 2:
+          r = 255;
+          g = mapSineToRange(cos(v*PI), 255);
+          b = mapSineToRange(sin(v*PI), 255);
+          break;
+        case 3:
+          r = g = b = mapSineToRange(sin(v*5.0*PI), 255);
+          break;
+      }
+
+      RGBColorType color = RGBColor::fromRGB(r, g, b);
+                              
+      leds.image().pixel(row, col) = color;
+    }
+  }
+  leds.stopDrawing();
+}
+
+void setup() {
+  leds.setup();
+  drawPlasma(0);
+  leds.startScanning();
+}
+
+unsigned long loopCounter = 0;
+unsigned long timeCount = 0;
+
+const unsigned long loopMod = 2000;
+
+void loop() {
+  leds.loop();
+  loopCounter++;
+
+  if (loopCounter == loopMod) {
+    timeCount++;
+    drawPlasma(timeCount);
+    loopCounter = 0;
+  }
+}
diff --git a/keywords.txt b/keywords.txt
@@ -7,7 +7,6 @@
 #######################################
 
 BaseLEDMatrix		KEYWORD1
-RGBColorType		KEYWORD1
 Frame				KEYWORD1
 Glyph				KEYWORD1
 GlyphBase			KEYWORD1
@@ -20,6 +19,8 @@ MutableRGBImage		KEYWORD1
 RGBAnimation		KEYWORD1
 RGBAnimationBase	KEYWORD1
 RGBAnimationSequence	KEYWORD1
+RGBColor			KEYWORD1
+RGBColorType		KEYWORD1
 RGBImage			KEYWORD1
 RGBImageBase		KEYWORD1
 RGBLEDBitLayout		KEYWORD1
@@ -34,6 +35,7 @@ TimerAction			KEYWORD1
 #######################################
 
 memcpy_smart		KEYWORD2
+fmod				KEYWORD2
 
 #######################################
 # Constants (LITERAL1)
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=Shift Register LED Matrix Lib
-version=0.9.0
+version=1.0.0
 author=Michael Kamprath <michael@kamprath.net>
 maintainer=Michael Kamprath <michael@kamprath.net>
 sentence=A driver for LED matrices that use shift registers to control rows and columns. 
diff --git a/src/Glyph.cpp b/src/Glyph.cpp
@@ -159,7 +159,7 @@ MutableGlyph::MutableGlyph(
 
 MutableGlyph::MutableGlyph( const GlyphBase& other )
 	: 	GlyphBase(other),
-		_bits( (bool*)memcpy_smart( 
+		_bits( (bool*)SRLEDMatrixUtils::memcpy_smart( 
 					new bool[(other.rows()*other.columns())],
 					other.bits(),
 					(other.rows()*other.columns())*sizeof(bool),
diff --git a/src/RGBColor.cpp b/src/RGBColor.cpp
@@ -18,6 +18,7 @@
 
 #include <math.h>
 #include "RGBColor.h"
+#include "SRLEDMatrixUtils.h"
 
 #if TWELVE_BIT_COLOR
 
@@ -31,7 +32,7 @@
 
 #endif
 
-RGBColorType RGBColor::fromRGB(char red, char green, char blue) {
+RGBColorType RGBColor::fromRGB(int red, int green, int blue) {
 	RGBColorType r = red/RGB_SCALE_VALUE;
 	RGBColorType g = green/RGB_SCALE_VALUE;
 	RGBColorType b = blue/RGB_SCALE_VALUE;
@@ -42,7 +43,7 @@ RGBColorType RGBColor::fromRGB(char red, char green, char blue) {
 }
 
 RGBColorType RGBColor::fromHSV(float hue, float saturation, float value) {
-	float H = ( hue < 0 ? ( fmod(hue,360) + 360.0) : fmod(hue,360) );
+	float H = ( hue < 0 ? ( SRLEDMatrixUtils::fmod(hue,360) + 360.0) : SRLEDMatrixUtils::fmod(hue,360) );
 
 	float C = value*saturation;
 	float X = C*(1 - fabs(float(int(H/60.0)%2-1)) );
@@ -85,7 +86,7 @@ RGBColorType RGBColor::fromHSV(float hue, float saturation, float value) {
 }
 
 RGBColorType RGBColor::fromHSL(float hue, float saturation, float lightness) {
-	float H = ( hue < 0 ? ( fmod(hue,360) + 360.0) : fmod(hue,360) );
+	float H = ( hue < 0 ? ( SRLEDMatrixUtils::fmod(hue,360) + 360.0) : SRLEDMatrixUtils::fmod(hue,360) );
 
 	float C = (1.0 - fabs(2.0*lightness - 1.0))*saturation;
 	float X = C*(1 - fabs(float(int(H/60.0)%2-1)) );
diff --git a/src/RGBColor.h b/src/RGBColor.h
@@ -139,7 +139,7 @@ namespace RGBColor {
 	 *	@param blue blue value between 0 and 255
 	 *  @return A RGBColorType value that closely approximates the passed color.
 	 */	 
-	RGBColorType fromRGB(char red, char green, char blue);
+	RGBColorType fromRGB(int red, int green, int blue);
 	
 	
 	/**
diff --git a/src/SRLEDMatrixUtils.cpp b/src/SRLEDMatrixUtils.cpp
@@ -24,7 +24,7 @@
 #include "SRLEDMatrixUtils.h"
 
 
-void * memcpy_smart(
+void * SRLEDMatrixUtils::memcpy_smart(
 			void * dest,
 			const void * src,
 			size_t n,
@@ -37,3 +37,7 @@ void * memcpy_smart(
 		return memcpy(dest, src, n);
 	}
 } 
+
+float SRLEDMatrixUtils::fmod(float x, float y) {
+	return x - y * floor(x/y);
+}
diff --git a/src/SRLEDMatrixUtils.h b/src/SRLEDMatrixUtils.h
@@ -17,15 +17,18 @@
 //     along with Shift Register LED Matrix Project.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef __SRLEDMATRIXUTILS_H__
 #define __SRLEDMATRIXUTILS_H__
+#include <Arduino.h>
 
+namespace SRLEDMatrixUtils {
+	void * memcpy_smart(
+				void * dest,
+				const void * src,
+				size_t n,
+				bool isSrcProgMem
+			);
 
-void * memcpy_smart(
-			void * dest,
-			const void * src,
-			size_t n,
-			bool isSrcProgMem
-		);
-
+	float fmod(float value, float modulo);
 
+}
 #endif // __RGBLEDMATRIXUTILS_H__
 

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@`
`24`	`24`	`#include "SRLEDMatrixUtils.h"`
`25`	`25`
`26`	`26`
`27`		`-void * memcpy_smart(`
	`27`	`+void * SRLEDMatrixUtils::memcpy_smart(`
`28`	`28`	`void * dest,`
`29`	`29`	`const void * src,`
`30`	`30`	`size_t n,`
`@@ -37,3 +37,7 @@ void * memcpy_smart(`
`37`	`37`	`return memcpy(dest, src, n);`
`38`	`38`	`}`
`39`	`39`	`}`
	`40`	`+`
	`41`	`+float SRLEDMatrixUtils::fmod(float x, float y) {`
	`42`	`+ return x - y * floor(x/y);`
	`43`	`+}`