Why Mesh
Why Particle
What is OpenThread
Architecture of Mesh Network
Gateway Node
Light Feature Nodes
Christmas Tree Construction
Christmas Ball Construction
Conclusion

Published December 31, 2019 © MIT

Magical OpenThread Mesh Christmas Lights!

Build an awesome Christmas light show with the timing coordinated over the OpenThread mesh network!

AdvancedFull instructions provided16 hours1,988

Magical OpenThread Mesh Christmas Lights!

Things used in this project

Hardware components

Particle Argon

Used for the gateway and to synchronize the timing.

Particle Xenon

1 used on the 20 foot tree (12 channels), 1 used to control 6 light balls, 1 used to control a second set of 6 light balls

Solid State Relay 8-Channel

1 - Christmas Tree, 1 - Christmas Balls, 1- Second set of Christmas Balls

Solid State Relay - 4 Channels

Used with 8-Channel set for the 12 Channels of the Christmas Tree.

Black pipe - 1/2 inch diameter - 10 foot

Used for the Christmas Tree

Black pipe - 1/2 inch coupler

Used to connect the 10 foot pipes for the Christmas Tree.

Story

Video of light show in action!

Why Mesh?

OpenThread and Particle make it so easy and fun to create an inexpensive coordinated Christmas light show! The traditional Christmas light displays all involve wiring to a central controller. With my design each mesh device is modular, and you only need to provide power. The timing of the light show is coordinated over the mesh network. The installation and take down is so much easier since all you need to do is provide power.

The other main benefit of the mesh network for me is that it extends the network beyond the range of my Wi-Fi network. I built devices in previous years that were all on Wi-Fi. My yard has dead zones and areas where Wi-Fi is out of range. The OpenThread mesh network is very smart and with no single point of failure and spread-spectrum techniques provide resistance to interference.

Why Particle?

Particle provides an IoT platform that makes the creation of mesh and other products so much easier. The development is so much more productive when you do not need to develop the plumbing and architecture from scratch. I have been developing IoT solutions for a long time and have built my own platforms from scratch, but now I am more productive than ever focusing on the business logic of the product instead of spending time building the platform. Particle's 3rd generation devices incorporate the OpenThread mesh.

What is OpenThread?

OpenThread was released by Google as an open-source implementation of Thread that Google created for Nest. Google released the networking technology to accelerate the development of products for the connected home to use Thead. (OpenThread website: https://openthread.io/)

My company is leveraging this technology for much more than connected home projects. This technology is also great for manufacturing and other enterprise projects because the installation of the solution is so much simpler than traditional ways of doing it by connecting wires between devices or controllers.

OpenThread is an IPv6-based, low-power, and primary features include: (Taken from OpenThread website: https://openthread.io/guides/thread-primer)

Simplicity - Simple installation, start up, and operation
Security - All devices in a Thread network are authenticated and all communications are encrypted
Reliability - Self-healing mesh networking, with no single point of failure, and spread-spectrum techniques to provide immunity to interference
Efficiency - Low-power Thread devices can sleep and operate on battery power for years
Scalability - Thread networks can scale up to hundreds of devices

OpenThread extends the goodness of IPv6 and network/web protocols that developers already know to the mesh network.

Architecture of Mesh Network

I created a mesh network that is easily expandable to add new nodes of light features each year. The network has 2 types of devices:

Gateway Node - Particle Argon (Wi-Fi + OpenThread)
Light Feature Nodes - Particle Xenons (OpenThread only)

Gateway Node

The gateway node is mainly used to bridge the Internet with the OpenThread mesh network. Particle makes the Argon and the Boron gateway devices. The Argon is built for Wi-Fi, but the Boron is built for cellular. The code that I wrote for the gateway was designed to be simple and to not block the gateway from performing other tasks. I plan on expanding the gateway to be used for my home automation and would not want the logic for the Christmas lights to produce a noticeable delay or prohibit another feature in my home automation.

The gateway code does the following functions:

Subscribes to mesh messages from the Christmas tree - The Christmas tree publishes a mesh message to announce that it is done with its light pattern. The gateway listens for this message and after receiving it will wait a second and then will publish a message for all light feature devices to start a new pattern.
Has a handler for a Particle function to update the mode. The Particle function is triggered from the cloud and the local gateway handler then relays the mode message across the mesh. Initially, I only had Particle function handlers on light feature nodes, but the cloud functions would often time out while the device was in a tight loop performing a light display. Having the handler on the gateway provides a quick response to the cloud acknowledging the function was invoked and the mesh ensures the delivery of the message to all the light feature nodes. The mesh has 15 modes of operation. Most of the modes are used to debug issues such as lighting up a single channel for placement of the feature or for finding bulbs that need replaced.
Sets the Wi-Fi credentials for all the access points that I normally connect to. This includes my house, my phone, and the office. This makes it easy to move the mesh to the office or to demo at a conference with my phone as an access point.
Heartbeat LED. I almost always add a heartbeat LED for my microcontroller projects. This adds a quick visual indicator that the device is alive and not hung. The Particle prototype devices all have an LED connected to the D7 pin included on the PCB, so I typically use this for the heartbeat LED.

Light Feature Nodes

All the light feature nodes are running an identical copy of the code. It would be a code maintenance nightmare to deploy different code or have different versions of the code for each device. Every time I add a new feature or fix a bug then I deploy the update to all the light feature nodes on the network. Particle has built a platform that enables over-the-air, OTA, updates from the Particle cloud through a gateway device to a mesh node. The mesh nodes are intended to be mounted high up in trees, so it is extremely nice and safer to be able to update the firmware at any time and during bad weather from the comfort of my living room or anywhere with an internet connection. Both the version of the OS and the firmware running the business logic on the device can be pushed from the Particle cloud to a device on the OpenThread mesh network! There is an issue with the Particle, Real Time Operating System, RTOS, where sometimes the OTA update to the mesh nodes have trouble caused from the tight loop of code running light pattern features. The easy work around is to first update the mode of the mesh nodes through the Particle function discussed in the gateway section above. I'll update the mode on all light feature nodes to exit the tight loop and turn all the lights on. Once I see that all the lights are on then I will run the OTA update and the firmware updates reliably every time.

All the mesh light feature nodes are running the same code, but each node knows its identity and can run special routines based on its identity. When the code initializes during the setup method, the light feature nodes subscribe to the Particle, particle/device/name, api which returns the friendly device name. The code can then have switches based on the friendly name identity of the device. So far there is only one switch in the code based on the identity of the device. The christmasTree device is special and treated as the leader and sends a message to the gateway to tell it that it is time to send out the synchronization mesh message when the christmasTree is idle on startup or idle after completing a light pattern. The christmasTree will keep sending messages every second incase the gateway is unplugged. Once the gateway acknowledges that the christmasTree is idle then it sends a mesh message on the christmasLights topic. All the light feature nodes subscribe to the christmasLights topic and kick off the light show upon message receipt. All the mesh nodes receive the message at practically the same time and are almost perfectly sequenced. Delays in sequencing as small as 20ms can be noticed so it is awesome that all the devices appear to work in complete unison.

Christmas Tree Construction

I built the 20-foot tree with some solid-state relays, Christmas lights, and black iron 1/2-inch plumbing pipe. The black iron pipe can be purchased from a hardware store in 10-foot sections so you will also need to join two sections of pipe with a coupler fitting. I hammered 3/4-inch PVC pipe into the ground around 1.5 feet so that I would not need to dig a hole to support the tree each year. The tree has 12 channels of solid-state relays and each channel has strands of 100 green light bulbs that I tie a string to and steak to the ground at each corner. It would be ideal to use pulse width modulation to control the brightness of each channel, but the Particle Xenon doesn't have 12 pwm pins available so I wrote my own pulse logic to control the brightness of each channel in a tight loop. I wrote a bunch of cool patterns to do things like fade channels that rotate around the tree and create cool effects.

Construction of the Twenty Foot Christmas Light Tree

20-foot Christmas OpenThread Mesh Tree

Christmas Ball Construction

I built 2 sets of 6 Christmas balls where each ball is 1 foot in diameter and has 200 Christmas lights. Each set of 6 balls has 1 Particle Xenon and a bank of solid-state relays controlling the brightness of each ball. Half of the balls are made with red lights and the other half are made with green lights. The 2 sets of 6 balls are on separate circuits so that each set of 6 balls could be mounted in different trees or displayed in different areas of the yard.

Picture of the construction of the Christmas Balls

Conclusion

OpenThread provides an excellent way to synchronize Christmas lights where you do not need to wire all of the lights to a central controller. The resilient mesh network is much more reliable than Wi-Fi. Particle provides a platform that makes using OpenThread and doing IoT much easier and much more fun too! I hope that you enjoyed the article and build some OpenThread Christmas magic lights of your own!

Code

int _pinHeartbeat = D7;
int _lastHeartbeatMillis = 0;
int _synchronizeMeshChristmasMillis = 0;
int _mode = 0;
bool _synchronizeMeshChristmasLights = false;

void setup() {
    Mesh.subscribe("christmasTree", christmasTreeMeshHandler);
    Particle.function("changeAllChristmasMode", changeAllChristmasMode);
    
    WiFi.setCredentials("LogicalLiving","^XxS8]%$r75MB=R/");
    WiFi.setCredentials("DanPhone", "!^YaZAnM[-&H`6Dm");
    WiFi.setCredentials("PME_Guest","4-)WL+>qTMTJnZ3r");
    
    pinMode(_pinHeartbeat, OUTPUT);
}

void loop() {
    heartBeat();
    synchronizeMeshChristmasLightsIfReady();
    delay(200);
}

void heartBeat() {
    if(_lastHeartbeatMillis + 500 < millis() ) {
        _lastHeartbeatMillis = millis();
        digitalWrite(_pinHeartbeat, !digitalRead(_pinHeartbeat));
    }
}

int changeAllChristmasMode(String mode) {
    if(mode == "") {
        _mode = _mode + 1;
    } else {
        _mode = mode.toInt();
    }
  
    if(_mode < 0 || _mode > 14){
        _mode = 0;
    }
    
    Mesh.publish("changeChristmasMode", String(_mode));
    //Mesh.publish("changeChristmasMode", "8");
    return _mode;
}

void christmasTreeMeshHandler(const char *event, const char *data){
    if (!_synchronizeMeshChristmasLights) {
        _synchronizeMeshChristmasMillis = millis();
    }
    _synchronizeMeshChristmasLights = true;
    Particle.publish("christmasLights", "ready-to-send-sync", PRIVATE);
}

void synchronizeMeshChristmasLightsIfReady() {
    //Allow for a delay before tries so that micros can sync with the particle cloud and do OS functions
    if (_synchronizeMeshChristmasLights && _synchronizeMeshChristmasMillis + 1000 < millis()) {
        _synchronizeMeshChristmasMillis = millis();
        
        //Keep trying each iteration until successful
        Particle.publish("christmasLights", "synchronize", PRIVATE);
        if (Mesh.publish("christmasLights", "synchronize") == SYSTEM_ERROR_NONE) {
            _synchronizeMeshChristmasLights = false; 
        }  
    }
}

int _pinSolidStateRelay1  = D0; 
int _pinSolidStateRelay2  = D1; 
int _pinSolidStateRelay3  = D2;
int _pinSolidStateRelay4  = D3;
int _pinSolidStateRelay5  = D4;
int _pinSolidStateRelay6  = D5;
int _pinSolidStateRelay7  = D6;
int _pinSolidStateRelay8  = D7;
int _pinSolidStateRelay9  = A4;
int _pinSolidStateRelay10 = A3;
int _pinSolidStateRelay11 = A2;
int _pinSolidStateRelay12 = A1;
int _pinHeartbeat = D7;
int _mode = 0;
int _synchronizeLightsMillis = 0;
int _lastHeartbeatMillis = 0;

bool _isChristmasTree = false;
bool _isChristmasBalls1 = false;
bool _isChristmasBalls2 = false;
bool _isRunningChristmasMagicRoutine = false;

void setup() {
    Particle.subscribe("particle/device/name", deviceNameHandler);
    Mesh.subscribe("christmasLights", christmasLightsMeshHandler);
    Mesh.subscribe("changeChristmasMode", changeChristmasModeMeshHandler);
    Particle.function("changeMode", changeModeHandler);
    Particle.publish("particle/device/name");  //Ask Particle cloud for device name
    
    RGB.control (true);
    pinMode(_pinSolidStateRelay1,  OUTPUT);
    pinMode(_pinSolidStateRelay2,  OUTPUT);
    pinMode(_pinSolidStateRelay3,  OUTPUT);
    pinMode(_pinSolidStateRelay4,  OUTPUT);
    pinMode(_pinSolidStateRelay5,  OUTPUT);
    pinMode(_pinSolidStateRelay6,  OUTPUT);
    pinMode(_pinSolidStateRelay7,  OUTPUT);
    pinMode(_pinSolidStateRelay8,  OUTPUT);
    pinMode(_pinSolidStateRelay9,  OUTPUT);
    pinMode(_pinSolidStateRelay10, OUTPUT);
    pinMode(_pinSolidStateRelay11, OUTPUT);
    pinMode(_pinSolidStateRelay12, OUTPUT);
    
    lightStrand(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
}

void loop() {
    switch (_mode) 
    {
        // Runs Christmas magic routine synchronized on all mesh devices
        case 0: 
            showIdentity();
            //showHeartbeat();  //It blinks a channel so only do during debugging
            
            if(_isChristmasTree) {
                synchronizeLights();
            }
            break;
            
        //light a single channel based on the mode
        case 1 ... 12: 
            rgbBlue();
            lightStrand(_mode==1, _mode==2, _mode==3, _mode==4, _mode==5, _mode==6, _mode==7, _mode==8, _mode==9, _mode==10, _mode==11, _mode==12, 300);
            break;
         
        //light all lights
        case 13: 
            rgbBlue();
            lightStrand(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 300);
            break;
            
        //light one at a time on a slow loop to figure out the sequence to put in the trees
        case 14: 
            rgbBlue();
            shiftStrandLeft(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2000, 12);
            break;
            
        // code to be executed if n doesn't match any cases
        default: 
            _mode = 0;
    }
    
}

void showHeartbeat() {
    if(_lastHeartbeatMillis + 500 < millis() ) {
        _lastHeartbeatMillis = millis();
        digitalWrite(_pinHeartbeat, !digitalRead(_pinHeartbeat));
    }
}

void showIdentity() {
    if(_isChristmasTree) {
        rgbGreen();
    }
    else if (_isChristmasBalls1) {
        rgbCyan();
    }
    else if (_isChristmasBalls2) {
        rgbYellow();
    }
    else {
        rgbRed();
    }
}

void synchronizeLights() {
    //Have a delay between mesh message trys
    if (_synchronizeLightsMillis + 1000 < millis()) {
        _synchronizeLightsMillis = millis();
        //Particle.publish("christmasTree", "ready-to-synchronize", PRIVATE);
        if (Mesh.publish("christmasTree", "ready-to-synchronize") != SYSTEM_ERROR_NONE){
            RGB.color(255,0,0); //Red
        }
    }
    delay(200);
}

void christmasLightsMeshHandler(const char *event, const char *data) {
    if (!_isRunningChristmasMagicRoutine){
        _isRunningChristmasMagicRoutine = true;
        christmasMagicRoutine();
        _isRunningChristmasMagicRoutine = false;
    }
}

void changeChristmasModeMeshHandler(const char *event, const char *data) {
    _mode = atoi(data);
}

int changeModeHandler(String mode) {
    if(mode == "") {
        _mode = _mode + 1;
    } else {
        _mode = mode.toInt();
    }
  
    return _mode;
}

void christmasMagicRoutine() {
    //The _mode can be updated at anytime from a Particle function
    if(_mode==0) { shiftStrandLeft(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 12); }
    if(_mode==0) { shiftStrandRight(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 12); }
    if(_mode==0) { fadeAllStrand(); }
    if(_mode==0) { fadeAllStrand(); }
    if(_mode==0) { fadeAllStrand(); }
    if(_mode==0) { fadeAllStrand(); }
    if(_mode==0) { shiftStrandLeft(1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 600, 5); }
    if(_mode==0) { shiftStrandLeft(1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 40, 12*4); }
    if(_mode==0) { lightStrand(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1000); }
    if(_mode==0) { diamond(false); }
    if(_mode==0) { delay(300); }
    if(_mode==0) { diamond(true); }
    if(_mode==0) { shiftStrandLeft(1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 150, 12*4); }
    if(_mode==0) { fadeStrandRotate(); }
    if(_mode==0) { fadeStrandRotate(); }
    if(_mode==0) { fadeStrandRotate(); }
    if(_mode==0) { fadeStrandRotate(); }
    if(_mode==0) { shiftStrandRight(1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 80, 12*6); }
    if(_mode==0) { lightStrand(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1000); }
}

void fadeStrandRotate() {
    fadeStrand(10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10, 10);
    fadeStrand(8, 6, 4, 2, 0, 2, 4, 6, 8, 10, 10, 10);
    fadeStrand(6, 4, 2, 0, 2, 4, 6, 8, 10, 10, 10, 8);
    fadeStrand(4, 2, 0, 2, 4, 6, 8, 10, 10, 10, 8, 6);
    fadeStrand(2, 0, 2, 4, 6, 8, 10, 10, 10, 8, 6, 4);
    fadeStrand(0, 2, 4, 6, 8, 10, 10, 10, 8, 6, 4, 2);
    fadeStrand(2, 4, 6, 8, 10, 10, 10, 8, 6, 4, 2, 0);
    fadeStrand(4, 6, 8, 10, 10, 10, 8, 6, 4, 2, 0, 2);
    fadeStrand(6, 8, 10, 10, 10, 8, 6, 4, 2, 0, 2, 4);
    fadeStrand(8, 10, 10, 10, 8, 6, 4, 2, 0, 2, 4, 6);
    fadeStrand(10, 10, 10, 8, 6, 4, 2, 0, 2, 4, 6, 8);
    fadeStrand(10, 10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10);
}

void fadeAllStrand() {
    for (int count = 0; count <= 10; count++)
    {
        fadeStrand(count,count,count,count,count,count,count,count,count,count,count,count);
    }
    for (int count = 10; count >= 0; count--)
    {
        fadeStrand(count,count,count,count,count,count,count,count,count,count,count,count);
    }
}

void diamond(boolean reverse) {
    if (reverse)
    {
        lightStrand(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 200);
        lightStrand(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 200);
        lightStrand(1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 200);
        lightStrand(1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 200);
        lightStrand(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 200);
        lightStrand(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 200);
        lightStrand(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200);
    }
    else
    {
        lightStrand(0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 200);
        lightStrand(0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 200);
        lightStrand(0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 200);
        lightStrand(0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 200);
        lightStrand(0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 200);
        lightStrand(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 200);
        lightStrand(0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 200);
        lightStrand(0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 200);
        lightStrand(0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 200);
        lightStrand(0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 200);
        lightStrand(0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 200);
        lightStrand(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200);
    }
}

void shiftStrandLeft(boolean light1,  boolean light2, boolean light3, boolean light4, boolean light5, 
                     boolean light6,  boolean light7, boolean light8, boolean light9, boolean light10, 
                     boolean light11, boolean light12, int delayMilliSeconds, int loopCount) {
    for (int count = 1; count <= loopCount; count++) 
    { 
        lightStrand(light1,  light2, light3, light4, light5, light6, light7, light8, light9, light10, 
                    light11, light12, delayMilliSeconds);
                    
        boolean lightHold = light1;
        light1  = light2;
        light2  = light3;
        light3  = light4;
        light4  = light5;
        light5  = light6;
        light6  = light7;
        light7  = light8;
        light8  = light9;
        light9  = light10;
        light10 = light11;
        light11 = light12;
        light12 = lightHold;
    }
}

void shiftStrandRight(boolean light1,  boolean light2, boolean light3, boolean light4, boolean light5, 
                      boolean light6,  boolean light7, boolean light8, boolean light9, boolean light10, 
                      boolean light11, boolean light12, int delayMilliSeconds, int loopCount) {
    for (int count = 1; count <= loopCount; count++) 
    { 
        lightStrand(light1, light2, light3, light4, light5, light6, light7, light8, light9, light10, light11, light12, delayMilliSeconds);
        
        boolean lightHold = light12;
        light12 = light11;
        light11 = light10;
        light10 = light9;
        light9  = light8;
        light8  = light7;
        light7  = light6;
        light6  = light5;
        light5  = light4;
        light4  = light3;
        light3  = light2;
        light2  = light1;
        light1  = lightHold;
    }
}

void lightStrand(boolean light1,  boolean light2, boolean light3, boolean light4, boolean light5,
                 boolean light6,  boolean light7, boolean light8, boolean light9, boolean light10, 
                 boolean light11, boolean light12, int delayMilliSeconds) {
    digitalWrite(_pinSolidStateRelay1,  light1);
    digitalWrite(_pinSolidStateRelay2,  light2);
    digitalWrite(_pinSolidStateRelay3,  light3);
    digitalWrite(_pinSolidStateRelay4,  light4);
    digitalWrite(_pinSolidStateRelay5,  light5);
    digitalWrite(_pinSolidStateRelay6,  light6);
    digitalWrite(_pinSolidStateRelay7,  light7);
    digitalWrite(_pinSolidStateRelay8,  light8);
    digitalWrite(_pinSolidStateRelay9,  light9);
    digitalWrite(_pinSolidStateRelay10, light10);
    digitalWrite(_pinSolidStateRelay11, light11);
    digitalWrite(_pinSolidStateRelay12, light12);
    delay(delayMilliSeconds); 
}

void fadeStrand(int light1, int light2, int light3, int light4, int light5, int light6, int light7, 
                int light8, int light9, int light10, int light11, int light12) {
    for (int pulse = 1; pulse <= 10; pulse++) { 
        lightStrand(pulse<=light1,  pulse<=light2, pulse<=light3, pulse<=light4, pulse<=light5, 
                    pulse<=light6,  pulse<=light7, pulse<=light8, pulse<=light9, pulse<=light10, 
                    pulse<=light11, pulse<=light12, 5);
    }
}

void deviceNameHandler(const char *topic, const char *data) {
    char deviceName[32] = "";
    strncpy(deviceName, data, sizeof(deviceName)-1);
    Particle.publish("DeviceNameSet", deviceName, PRIVATE);
    if (strcmp(deviceName,"ChristmasTree")==0) {
        _isChristmasTree=true;
        Particle.publish("WhatIAm", "ChrismasTree", PRIVATE);
    } else if (strcmp(deviceName,"ChristmasBalls1")==0) {
        _isChristmasBalls1=true;
        Particle.publish("WhatIAm", "ChrismasBalls1", PRIVATE);
    } else if (strcmp(deviceName,"ChristmasBalls2")==0) {
        _isChristmasBalls2=true;
        Particle.publish("WhatIAm", "ChrismasBalls2", PRIVATE);
    }
}

void rgbGreen()  { RGB.color(0,255,0); }
void rgbCyan()   { RGB.color(0,255,255); }
void rgbYellow() { RGB.color(128,255,0); }
void rgbBlue()   { RGB.color(0,0,255); }
void rgbRed()    { RGB.color(255,0,0); }

Credits

Dan Thyer

3 projects • 10 followers

Husband, father, business owner, software architect, IoT, web/mobile development, microcontrollers- basically a total geek. Microsoft RD/MVP

Magical OpenThread Mesh Christmas Lights!