Why Arduino
Time Management and state and trigger flags
Button assumptions
Hardware
Wiring
Lighting Effects
Parts
Steps
Making projects more interactive
Did you know you can receive this project

Published September 25, 2018 © Apache-2.0

Making a Lightshow with Arduino

Using an Arduino Nano on an expansion board with a push-button to change the color palette mode of the RGB LED strip.

IntermediateFull instructions provided1 hour7,969

Things used in this project

Hardware components

Arduino Nano R3

Arduino Nano Expansion Board

WS2811 / WS2812 RGB Light Strips

Push-button switch

Story

They are in games, decorations, shadow boxes, sign borders, torches, spotlights, and so on...

RGB Torches

Halloween Animatronics

Using an Arduino Nano on an expansion board with a push-button to change the color palette mode of the RGB LED strip. A microphone module is used to detect sound and alter the speed of flashing lights.

Arduino Pro-Mini, Uno, Nano on Expansion Board

Why Arduino?

The greatest advantage to using the Arduino family of microcontrollers for these types of projects, is that they are ubiquitous. Since they are so available, they are inexpensive and you can find open-source software to get started. If you’ve ever had the opportunity to work with an Arduino Uno microcontroller board, then you’ve probably executed the flashing LED example. Going further, you might attach a button, or switch, to trigger the LED or to turn it off making the project interactive.

There are many sensors that could be connected to the Arduino Uno and setup to trigger events, such as the LED flashing, using threshold values that we would need to experiment with in order to figure out what settings work best for creating the effect we want.

While the examples that come with the Arduino software and the examples included with libraries are an excellent start to a project; the Arduino family of microcontrollers is often grossly underutilized in many projects. Sure microcontrollers are limited in how many instructions it can run and hitting the program size limit doesn’t take very long when you want to control more than a few blinking LEDs.

Even with creative variable handling and custom libraries, eventually, there is a need for another microcontroller or to move to a larger one. In my hydroMazing Smart Garden System and in my Alien Invasion Slot Machine projects, I push the Arduino closer to its limits.

Time Management and state and trigger flags

At its most basic, a microcontroller loops through a set of instructions handling each action with the focus of The Red Eye of Sauron from Lord of the Rings. There are a few interrupts that can be configured should an event be so important to receive the full attention of the microcontroller. Using some form of time management creates a state machine. If x amount of time has passed since x event, then do something and so on...

“The behavior of state machines can be observed in many devices in modern society that perform a predetermined sequence of actions depending on a sequence of events with which they are presented. Simple examples are vending machines, which dispense products when the proper combination of coins is deposited, elevators, whose sequence of stops is determined by the floors requested by riders, traffic lights, which change sequence when cars are waiting, and combination locks, which require the input of combination numbers in the proper order.” https://en.wikipedia.org/wiki/Finite-state_machine

There are rare instances where: RTOS, AI, neural networks exist on microcontrollers, but that’s best left to software-oriented systems such as a Raspberry Pi.

After trying many different timer and time management libraries I felt they were either too much or not enough of what I was wanting in my timers. A set of timers that are easy to set, keep track of their own state, and each have their own trigger flags.

Button assumptions

push-button switches

Interacting with an electronics device such as a microcontroller or computer system is relatively easy and typically provided as an example for developers looking to use the device in their project. Press a button and an LED illuminates. A button or switch may seem like a simple sensor input, but it’s not.

The device’s system resources are consumed waiting and watching for a button press. When we use a button in a project we typically think of it being activated when pressed. Then what? What should happen if the user holds the button in the active position? Will the button be counted as pressed once, or is the program going to count each second, or x amount of time, as another button press? Does the program need to know that the button has been released?

Hardware

I’m going to be adding on a lot of peripheral devices and moving away from basic prototyping. Rather than using the Arduino Uno and a protoboard or breadboard for this project, I’m using the Arduino Nano on an expansion board.

custom wiring harness

Wiring

Keep it simple using common wiring colors, keep it modular so connections can be made with ease, keep your project sustainable; a part can be replaced rather than the entire system. The DuPont wire connectors that come with prototyping starter kits makes it easy to create your own custom wiring connections. The wires are easy to solder when a more permanent connection is needed. I make custom wiring harnesses for neater, cleaner, and more easily connectable modules.

Lighting Effects

There many RGB LED options, so I will be focusing on the WS2811/WS2812 modules. Single RGB LEDs to strings of RGB LEDs in various configurations. Most of the RGB options will have three wires for connecting to the microcontroller board and require 5vdc or 12vdc.

RGB Light String Calibration

Unless you are designing a new printed circuit board, use DC/DC conversion modules to convert your power to the needs of your project. You might need to step-up voltage from 3v to 5v, or maybe step-down 12v to 5v?

*** The more lights added, the more power needed. ***

The Arduino Uno, and variants, should only be used for directly powering peripheral modules and not devices. Consider the maximum current consumption when determining what is a device and what is a module. A string of lights is more of a device as opposed to a panel indicator light, motor controller boards are modules, not the motors they drive, MOSFET boards, not the valves or solenoids that they control.

Common Options for Power

USB Powered Devices
AC/DC wall-wart Power Supplies
Rechargeable Batteries
Solar Panels

power options

Parts:

Arduino Nano
Expansion Board
USB to mini USB cord
AC/DC Outlet Power Adapter
Project Box
(1-4) strips of 10 RGB 12mm LEDs.
(1) push-buttons
microphone

Arduino Nano Expansion Board, watch the pins!!

Steps:

Insert Arduino Nano into the Expansion Board by carefully pressing the Nano pins into the expansion boards headers. Note the picture where only half of the pins are correctly inserted. Plan to provide power using USB to mini USB cord. Optionally, AC/DC Outlet Power Adapter.

Prepare the following wiring connections to the expansion board by soldering and protecting with heat-shrink:

(1-4) strips of 10 RGB 12mm LEDs.
(1) push-button
microphone

Programming considerations:

brightness of lights
color palette
speed of flashing lights
what triggers change?

I’ve created several color palettes by porting the sample code from the FastLED library examples to my base code templates. with a push-button input to change the color palette mode of the RGB LED strip. See Arduino FastLED Library.

Connect the push-button to the expansion board.

Connect strip(s) of 10 RGB 12mm LEDs to the expansion board and upload test code.

Optionally, connect the potentiometer to the expansion board and upload test code.

microphone and PIR sensors

Making projects more interactive

Every sensor gives us a data-point to work with, providing an input so that our program can make a decision based on its current environment or what happens when conditions are met. Going further with the project, I’ve added a microphone to detect sound, and at a later time, I’ll add a PIR sensor to detect motion.

Connect the microphone to the expansion board and upload test code.

box it up!

Complete the project with an enclosure.

Drill 7/16” - 1/2” holes into the project box:
HOLE 1: side ~ USB to mini USB cord ~ Optionally, AC/DC Outlet Power Adapter
HOLE 2: cover ~ push-button
HOLE 3: side ~ 1-4 x strips of 10 RGB 12mm LEDs

completed project

Did you know you can receive this project?

Join CoreConduit

Follow my work or get involved at http://www.hydroMazing.com

Code

/*
* @file CustomFastLED.h
* Copyright (C) 2018 Cory J. Potter - All Rights Reserved
* You may use, distribute and modify this code under the
* terms of the LICENSE.txt
* NOT INTENDED FOR COMMERCIAL USE!
* You should have received a copy of the LICENSE.txt with
* this file. If not, please write to: <bitsandbots@gmail.com>
*/

#ifndef __CUSTOM_FASTLED_H__
#define __CUSTOM_FASTLED_H__

#ifdef ARDUINO

#define NUM_STRIPS 1
#define NUM_LEDS_PER_STRIP 10
// #define NUM_STRIPS 1
// #define NUM_LEDS_PER_STRIP 24
#define NUM_LEDS NUM_LEDS_PER_STRIP * NUM_STRIPS
#define BRIGHTNESS 200
uint8_t brightness = BRIGHTNESS;
#define COLOR_ORDER RGB
//#define COLOR_ORDER RGB
//#define COLOR_ORDER BRG
CRGBPalette16 currentPalette;
TBlendType    currentBlending;

CRGB leds[NUM_LEDS];

bool gReverseDirection = false;
// Fire2012 with programmable Color Palette
//
CRGBPalette16 gPal;
// Default 55, suggested range 20-100
int COOLING = 55;
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
int SPARKING = 120;

////////////////////////////////////////////////////////////////////////////////////////////////////
uint8_t startIndex = 0;
uint8_t selectedMode = 0;
uint8_t selectedPalette = 0;


void calibrateLEDstrip();
void WhiteTwinkle( void );
void Confetti( void );
void EnergyOutput( void );
void EnergyInput( void );
void Fire2012WithPalette();
void SetupOrangeAndWhiteStripedPalette();
void SetupBlackAndWhiteStripedPalette();
void SetupPurpleAndGreenPalette();
void SetupYellowAndOrangePalette();
void SetupRainbowPalette();
void SetupBoyGeorgePalette();
void SetupRedWhiteBluePalette();

void calibrateLEDstrip()
{
	leds[0] = CRGB(255,0,0);
	leds[1] = CRGB(0,255,0);
	leds[2] = CRGB(0,255,0);
	leds[3] = CRGB(0,0,255);
	leds[4] = CRGB(0,0,255);
	leds[5] = CRGB(0,0,255);
	FastLED.show();
	delay(1000);

	for(int i = 0; i < NUM_LEDS; i++) {
		leds[i] = CRGB::Red;
		FastLED.show();
		leds[i] = CRGB::Black;
		delay(100);
	}
}

void WhiteTwinkle( void )
{
	for( int x = NUM_LEDS; x >= 0; x-- )
	{
		leds[x] = CRGB(0,0,0);
		leds[x] = CRGB::AntiqueWhite;
	}
	FastLED.setBrightness(1);
	FastLED.show();
}


void Confetti( void ) {
	FastLED.setBrightness( random( brightness,BRIGHTNESS ) );
	// Dim a color by ~6% (16/256ths), eventually fading to full black.
	fadeToBlackBy(leds, NUM_LEDS, 16);
	int r = random16(NUM_LEDS);
//	if (DEBUG) { Serial.print("r16 = "); Serial.println(r); }
	int r8 = random8();
//	if (DEBUG) { Serial.print("r8 = "); Serial.println(r8); }
	if (!leds[r]) { leds[r] += CHSV( r8, 255, 255); }
	FastLED.show();
	uint8_t control = random(0,2);
	if ( control == 1 ) {
		FastLED.delay(random(50, 100));
	}
}

void EnergyOutput( void )
{
	// First slide the led in one direction
	for(int y = 0; y <= NUM_LEDS; y++) {
		// Set the i'th led to color
		leds[y] = CRGB::AntiqueWhite;
		// Show the leds
		FastLED.show();
		// now that we've shown the leds, reset the i'th led to black
		leds[y] = CRGB::Black;
		// Wait a little bit before we loop around and do it again
		delay( 60 );
		if (DEBUG) { Serial.print("power "); Serial.println(y); }
	}
}

void EnergyInput( void )
{
	// Now go in the other direction.
	for(int n = NUM_LEDS; n >= 0; n--) {
		// Set the i'th led to color
		leds[n] = CRGB::AntiqueWhite;
		// Show the leds
		FastLED.show();
		// now that we've shown the leds, reset the i'th led to black
		leds[n] = CRGB::Black;
		// Wait a little bit before we loop around and do it again
		delay(60);
	}
	
}

void Fire2012WithPalette()
{
	// Array of temperature readings at each simulation cell
	static byte heat[NUM_LEDS];

	// Step 1.  Cool down every cell a little
	for( int i = 0; i < NUM_LEDS; i++) {
		heat[i] = qsub8( heat[i],  random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
	}
	
	// Step 2.  Heat from each cell drifts 'up' and diffuses a little
	for( int k= NUM_LEDS - 1; k >= 2; k--) {
		heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
	}
	
	// Step 3.  Randomly ignite new 'sparks' of heat near the bottom
	if( random8() < SPARKING ) {
		int y = random8(7);
		heat[y] = qadd8( heat[y], random8(160,255) );
	}

	// Step 4.  Map from heat cells to LED colors
	for( int j = 0; j < NUM_LEDS; j++) {
		// Scale the heat value from 0-255 down to 0-240
		// for best results with color palettes.
		byte colorindex = scale8( heat[j], 240);
		CRGB color = ColorFromPalette( gPal, colorindex);
		int pixelnumber;
		if( gReverseDirection ) {
			pixelnumber = (NUM_LEDS-1) - j;
			} else {
			pixelnumber = j;
		}
		leds[pixelnumber] = color;
	}
}


/********************* COLOR PALETTES *********************/

void SetupOrangeAndWhiteStripedPalette()
{
	// 'black out' all 16 palette entries...
	fill_solid( currentPalette, 16, CRGB::Orange);
	// and set even to white.
	currentPalette[0] = CRGB::White;
	currentPalette[2] = CRGB::White;
	currentPalette[4] = CRGB::White;
	currentPalette[6] = CRGB::White;
	currentPalette[8] = CRGB::White;
	currentPalette[10] = CRGB::White;
	currentPalette[12] = CRGB::White;
	currentPalette[14] = CRGB::White;
}

void SetupBlackAndWhiteStripedPalette()
{
	// 'black out' all 16 palette entries...
	fill_solid( currentPalette, 16, CRGB::Black);
	// and set even to white.
	currentPalette[0] = CRGB::White;
	currentPalette[2] = CRGB::White;
	currentPalette[4] = CRGB::White;
	currentPalette[6] = CRGB::White;
	currentPalette[8] = CRGB::White;
	currentPalette[10] = CRGB::White;
	currentPalette[12] = CRGB::White;
	currentPalette[14] = CRGB::White;
}

// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{
	CRGB purple = CHSV( HUE_PURPLE, 255, 255);
	CRGB green  = CHSV( HUE_GREEN, 255, 255);
	CRGB black  = CRGB::Black;
	currentPalette = CRGBPalette16(
	green,  black, purple,
	green,  black, purple,
	green,  black, purple,
	green,  black, purple,
	green,  black, purple, black );
}

// This function sets up a palette of purple and green stripes.
void SetupYellowAndOrangePalette()
{
	CRGB yellow = CHSV( HUE_YELLOW, 255, 255);
	CRGB orange  = CHSV( HUE_ORANGE, 255, 255);
	CRGB black  = CRGB::Black;
	currentPalette = CRGBPalette16(
	yellow,  black, orange,
	yellow,  black, orange,
	yellow,  black, orange,
	yellow,  black, orange,
	yellow,  black, orange,black);
}

void SetupRainbowPalette()
{
	// 'black out' all 16 palette entries...
	fill_solid( currentPalette, 16, CRGB::Black);
	currentPalette[0] = CRGB::Red;
	currentPalette[1] = CRGB::Orange;
	currentPalette[2] = CRGB::Yellow;
	currentPalette[3] = CRGB::Green;
	currentPalette[4] = CRGB::Blue;
	currentPalette[5] = CRGB::Purple;
	currentPalette[6] = CRGB::Red;
	currentPalette[7] = CRGB::Orange;
	currentPalette[8] = CRGB::Yellow;
	currentPalette[9] = CRGB::Green;
	currentPalette[10] = CRGB::Blue;
	currentPalette[11] = CRGB::Purple;
	currentPalette[12] = CRGB::Red;
	currentPalette[13] = CRGB::Orange;
	currentPalette[14] = CRGB::Yellow;
	currentPalette[15] = CRGB::Green;
}

void SetupBoyGeorgePalette()
{
	currentPalette[0] = CRGB::Red;
	currentPalette[1] = CRGB::Gold;
	currentPalette[2] = CRGB::Green;
	currentPalette[3] = CRGB::Red;
	currentPalette[4] = CRGB::Gold;
	currentPalette[5] = CRGB::Green;
	currentPalette[6] = CRGB::Red;
	currentPalette[7] = CRGB::Gold;
	currentPalette[8] = CRGB::Green;
	currentPalette[9] = CRGB::Red;
	currentPalette[10] = CRGB::Gold;
	currentPalette[11] = CRGB::Green;
	currentPalette[12] = CRGB::Red;
	currentPalette[13] = CRGB::Gold;
	currentPalette[14] = CRGB::Green;
	currentPalette[15] = CRGB::Red;
}
void SetupRedWhiteBluePalette()
{
	// 'black out' all 16 palette entries...
	fill_solid( currentPalette, 16, CRGB::Black);
	currentPalette[0] = CRGB::Red;
	currentPalette[1] = CRGB::White;
	currentPalette[2] = CRGB::Blue;
	currentPalette[4] = CRGB::Red;
	currentPalette[5] = CRGB::White;
	currentPalette[6] = CRGB::Blue;
	currentPalette[7] = CRGB::Red;
	currentPalette[8] = CRGB::White;
	currentPalette[9] = CRGB::Blue;
	currentPalette[10] = CRGB::Red;
	currentPalette[11] = CRGB::White;
	currentPalette[12] = CRGB::Blue;
	currentPalette[13] = CRGB::Red;
	currentPalette[14] = CRGB::White;
	currentPalette[15] = CRGB::Blue;
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
	for( int i = 0; i < NUM_LEDS; i++) {
		leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
		colorIndex += 1;
	}
}

void ChangePalette( uint8_t mode )
{
	switch ( mode )
	{
		case 1:  currentPalette = RainbowColors_p;
		break;
		case 2:   currentPalette = CloudColors_p;
		break;
		case 3:   currentPalette = OceanColors_p;
		break;
		case 4:  currentPalette = PartyColors_p;
		break;
		case 5:  currentPalette = ForestColors_p;
		break;
		case 6:	 SetupRainbowPalette();
		break;
		case 7:  SetupBoyGeorgePalette();
		break;
		case 8:  SetupRedWhiteBluePalette();
		break;
		case 9:  SetupOrangeAndWhiteStripedPalette();
		break;
		case 10:  SetupBlackAndWhiteStripedPalette();
		break;
		case 11:  SetupPurpleAndGreenPalette();
		break;
		case 12:  SetupYellowAndOrangePalette();
		break;
	}
}


#else
#error This code is only for use on Arduino.
#endif // ARDUINO
#endif // __CUSTOM_FASTLED_H__

Credits

Cory Potter

9 projects • 88 followers

Technical Craftsman specializing in bridging the gap between electronics and software engineering, with unconventional approach to problems.

Making a Lightshow with Arduino