diychristmas.org wiki - User contributions [en]

Super-sized Animatronic Ball Ornaments

2023-12-22T05:35:37Z

MikeKrebs:

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Watch The Video! Click HERE] - from Tory Street Lights'''

[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The ornament is handmade polyester resin over fiberglass and cheesecloth with animatronic eyes, eyelids, eyebrows and mouth.

'''How did it go over?'''
Maybe you want to make a splash in your display? Terry said, ''"With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public."''

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this: [https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch. He custom designed the ornaments and made them by hand. He thinks it was about a three month journey and they each turned out to be quite expensive ([[#Cost]]).

This entry was edited by MikeKrebs but most of it is Terry's words either from the video or from correspondence with him. So, when you read first person comments, you should hear Terry talking and when you read third person comments, that would be Mike putting words to Terry's project. If you make something similar and want to add your comments, please do so!
== Features ==
*Large ornament - about 2 feet across
*Sculpted eye sockets
*Eyes move together for natural look
*Eye moves in two dimensions - up/down and left-right
*Eye movements can be done at same time (roll eyes!)
*Eyebrows are independently controlled
*Ornament turns away from crowd when not doing show
*Controlled via Renard protocol
*Can be controlled by wireless ESP8266 module
*All custom made

== Bill of Materials ==

*Big ball (25 inches)
*PVA glue (Elmers!)
*Paper towels for mache
*Cheesecloth
*Fiberglass and polyester resin
*Bog filler (Bondo type could be used) to form up eye contours
*Planting container

For the record there are eight servos in use in each ornament.
*1 - Mouth
*2 - Slow Rotate
*3 - Eyes Up / Down
*4 - Eyes Left / Right
*5 - Left Eyelid
*6 - Right Eyelid
*7 - Left Eye Brow
*8 - Right Eyebrow

The individual control of the eyelids was so that I could make them wink, while the separate eyebrows were also for expression / effect.
*There is also a motor that turns the whole assembly.

*brass rods
*wire rods
*bicycle spokes
*foam board
*board board

*Renard board
*Renard servo software
*Opto-couplers
*Drivers

*1000 watt slide projector with template

*Chris Maloney's Audacity converter.

*Many cans of paint.

== Eye Mechanism ==
The inspiration was [https://www.youtube.com/watch?v=6jqvu_MQ5pc Marshall Tearle's Eyes]. If you look his over, you will see how Tory Street Light's came together.

Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

== Ornament Mounting ==
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

== Ornament Rotation ==
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

Here you can see the gears including the limit switches and the stop bolt that provide the stop position for "Off" and "On".
[[FILE:Complete_view_of_Turning_Mech_fromTop2.jpg]]

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

== Renard controller ==
[[FILE:32_Channel_Ren_Servo_Controller_Box2.jpg]]

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed electric drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain. The Renard controller talks to the opto-couplers via the cable bundles on the right side of the case.

The Renservo software came from Dirk’s Wiki, originally written by Chris Maloney "Ctmal" on the forum and updated by “GDYRDAVE”, who passed away a couple of years ago. :-(

[[Firmware_-_multiple_versions]]

I used the Pic16F688 version which worked fine for me. I tried the PIC 16F1825 version, this worked fine but inverted the data/servo positions and as such I didn’t have the time to correct all the data so I returned to the PIC16F688.

== Opto-coupler and buffer box ==
[[FILE:32_Channel_Ren_Servo_Opto_Buffer_and_Gating_Box2.jpg]]

The Opto-coupler and buffer box also has 32 channels available. The opto-couplers are wired to the buffer chips that send the signals to the servos and relays. The buffer/driver chips are hidden under the linking cables on the right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a Renard controller channel, applied through an opto-coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence.

== Cost ==
The whole project took around three months or so, full time. Thankfully I am retired; so time is not too much of a problem. I did not have a budget for the project. It just had a life of its own, and as it transpired, it was a good thing I didn’t. Only when the project was completed I managed to locate all the invoices / till dockets and totaled them up. It was a good thing I was sitting down when I saw the bottom line!! They cost around $600.00 (US) each, way above my guestimation!! With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public.

The most expensive items would be the Fiberglass Dynal Cloth, Polyester Resin and the thinners. Then the Rustoleum Glitter spray-can paint, these were about $20.00 (US) per can and I used around 10 per Ornament. Also about 8 or 10 Cans of clear sealing spray, thankfully slightly cheaper than the Glitter paint! Next in line would be the several pounds of Polyester builders / car body filler or “Bog” that was required to form/create the eyebrows and eye sockets. The next most expensive would be the big Jumbo servos, they were around the $30.00 – $40.00 each, two per ornament, plus spares, as well as the very fast eyelid servo’s they were in the region of $15.00 each with two per Ornament, plus spares.

It was fortuitous that I was able to acquire from my employer, prior to retirement, discarded, out of spec, Ball races, big gears, micro switches and the industrial plastic parts that I used to create the eye mechanism. The ball races, (8 per ornament) and the mounting plates that support the ornaments are included in the above!

Super-sized Animatronic Ball Ornaments

2023-12-22T05:32:45Z

MikeKrebs:

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Watch The Video! Click HERE] - from Tory Street Lights'''

[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The ornament is handmade polyester resin over fiberglass and cheesecloth with animatronic eyes, eyelids, eyebrows and mouth.

'''How did it go over?'''
Maybe you want to make a splash in your display? Terry said, ''"With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public."''

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this: [https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch. He custom designed the ornaments and made them by hand. He thinks it was about a three month journey and they each turned out to be quite expensive ([[#Cost]]).

This entry was edited by MikeKrebs but most of it is Terry's words either from the video or from correspondence with him. So, when you read first person comments, you should hear Terry talking and when you read third person comments, that would be Mike putting words to Terry's project. If you make something similar and want to add your comments, please do so!
== Features ==
*Large ornament - about 2 feet across
*Sculpted eye sockets
*Eyes move together for natural look
*Eye moves in two dimensions - up/down and left-right
*Eye movements can be done at same time (roll eyes!)
*Eyebrows are independently controlled
*Ornament turns away from crowd when not doing show
*Controlled via Renard protocol
*Can be controlled by wireless ESP8266 module
*All custom made

== Bill of Materials ==

*Big ball (25 inches)
*PVA glue (Elmers!)
*Paper towels for mache
*Cheesecloth
*Fiberglass and polyester resin
*Bog filler (Bondo type could be used) to form up eye contours
*Planting container

For the record there are eight servos in use in each ornament.
*1 - Mouth
*2 - Slow Rotate
*3 - Eyes Up / Down
*4 - Eyes Left / Right
*5 - Left Eyelid
*6 - Right Eyelid
*7 - Left Eye Brow
*8 - Right Eyebrow

The individual control of the eyelids was so that I could make them wink, while the separate eyebrows were also for expression / effect.
*There is also a motor that turns the whole assembly.

*brass rods
*wire rods
*bicycle spokes
*foam board
*board board

*Renard board
*Renard servo software
*Opto-couplers
*Drivers

*1000 watt slide projector with template

*Chris Maloney's Audacity converter.

*Many cans of paint.

== Eye Mechanism ==
The inspiration was [https://www.youtube.com/watch?v=6jqvu_MQ5pc Marshall Tearle's Eyes]. If you look his over, you will see how Tory Street Light's came together.

Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

== Ornament Mounting ==
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

== Ornament Rotation ==
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

Here you can see the gears including the limit switches and the stop bolt that provide the stop position for "Off" and "On".
[[FILE:Complete_view_of_Turning_Mech_fromTop2.jpg]]

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

== Renard controller ==
[[FILE:32_Channel_Ren_Servo_Controller_Box2.jpg]]

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed electric drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain. The Renard controller talks to the opto-couplers via the cable bundles on the right side of the case.

The Renservo software came from Dirk’s Wiki, originally written by Chris Maloney "Ctmal" on the forum and updated by “GDYRDAVE”, who passed away a couple of years ago. :-

[[Firmware_-_multiple_versions]]

I used the Pic16F688 version which worked fine for me. I tried the PIC 16F1825 version, this worked fine but inverted the data/servo positions and as such I didn’t have the time to correct all the data so I returned to the PIC16F688.

== Opto-coupler and buffer box ==
[[FILE:32_Channel_Ren_Servo_Opto_Buffer_and_Gating_Box2.jpg]]

The Opto-coupler and buffer box also has 32 channels available. The opto-couplers are wired to the buffer chips that send the signals to the servos and relays. The buffer/driver chips are hidden under the linking cables on the right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a Renard controller channel, applied through an opto-coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence.

== Cost ==
The whole project took around three months or so, full time. Thankfully I am retired; so time is not too much of a problem. I did not have a budget for the project. It just had a life of its own, and as it transpired, it was a good thing I didn’t. Only when the project was completed I managed to locate all the invoices / till dockets and totaled them up. It was a good thing I was sitting down when I saw the bottom line!! They cost around $600.00 (US) each, way above my guestimation!! With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public.

The most expensive items would be the Fiberglass Dynal Cloth, Polyester Resin and the thinners. Then the Rustoleum Glitter spray-can paint, these were about $20.00 (US) per can and I used around 10 per Ornament. Also about 8 or 10 Cans of clear sealing spray, thankfully slightly cheaper than the Glitter paint! Next in line would be the several pounds of Polyester builders / car body filler or “Bog” that was required to form/create the eyebrows and eye sockets. The next most expensive would be the big Jumbo servos, they were around the $30.00 – $40.00 each, two per ornament, plus spares, as well as the very fast eyelid servo’s they were in the region of $15.00 each with two per Ornament, plus spares.

It was fortuitous that I was able to acquire from my employer, prior to retirement, discarded, out of spec, Ball races, big gears, micro switches and the industrial plastic parts that I used to create the eye mechanism. The ball races, (8 per ornament) and the mounting plates that support the ornaments are included in the above!

Arduino and pixels V1

2020-10-19T03:00:49Z

MikeKrebs: Created page with "This is untested code. Awaiting feedback. Serial may not support this many pixels at 115200. <nowiki> // Basic Vixen "generic" serial // - Setup a generic serial controller..."

This is untested code. Awaiting feedback. Serial may not support this many pixels at 115200.
<nowiki>
// Basic Vixen "generic" serial
// - Setup a generic serial controller to use this sketch

#include <FastLED.h> //include the FastLED library in the Arduino project
#define LED_PIN1 2 //for first arc strip of 100 LEDs, pin 2 on the MEGA
#define LED_PIN2 3 //for second arc strip of 100 LEDs, pin 3 on the MEGA
#define LED_PIN3 4 //for third arc strip of 100 LEDs, pin 4 on the MEGA
#define LED_PIN4 5 //for fourth arc strip of 100 LEDs, pin 5 on the MEGA
#define LED_PIN5 6 //for fifth arc strip of 100 LEDs, pin 6 on the MEGA

// Vixen information
// speed for the com port for talking with player
const long BAUD_RATE = 115200L;
#define NUM_LEDS 100
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

#define GRB_ORDER GRB //pixel strips is set to use GRB color codes

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change

#define LED_TYPE WS2811 //type of LED

//create arrays to hold the FastLED CRBG code for each of the 50 pixels in the:
CRGB leds1[NUM_LEDS]; //first arc.
CRGB leds2[NUM_LEDS]; //second arc.
CRGB leds3[NUM_LEDS]; //third arc.
CRGB leds4[NUM_LEDS]; //fourth arc.
CRGB leds5[NUM_LEDS]; //fifth arc.

int g; //a variable for loop section

void setup() {
delay(1000);
Serial.begin(BAUD_RATE);
pinMode(LED_PIN1, OUTPUT); //set pins to output. PIN1 is pin 2 on the Arduino board.
pinMode(LED_PIN2, OUTPUT);
pinMode(LED_PIN3, OUTPUT);
pinMode(LED_PIN4, OUTPUT);
pinMode(LED_PIN5, OUTPUT);

////Set up the pixel strips to run using FastLED
FastLED.addLeds<LED_TYPE, LED_PIN1, GRB_ORDER>(leds1, NUM_LEDS).setCorrection(TypicalLEDStrip); //for the first arc
FastLED.addLeds<LED_TYPE, LED_PIN2, GRB_ORDER>(leds2, NUM_LEDS).setCorrection(TypicalLEDStrip); //for the second arc
FastLED.addLeds<LED_TYPE, LED_PIN3, GRB_ORDER>(leds3, NUM_LEDS).setCorrection(TypicalLEDStrip); //for the third arc
FastLED.addLeds<LED_TYPE, LED_PIN4, GRB_ORDER>(leds4, NUM_LEDS).setCorrection(TypicalLEDStrip); //for the fourth arc
FastLED.addLeds<LED_TYPE, LED_PIN5, GRB_ORDER>(leds5, NUM_LEDS).setCorrection(TypicalLEDStrip); //for the fifth arc
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop() {
if (Serial.available() > 0) {
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
FastLED.show(); //then we tell FastLED to show the pixels!
}
}

void readSequenceData()
{
// We assume that since we found the header, we can just read the rest of the bytes
for (g = 0; g < NUM_LEDS; g++) {
Serial.readBytes( ( char*)(&leds1[g]), 3);
}
for (g = 0; g < NUM_LEDS; g++) { //then we read the next 300 bytes for the second arc of LEDs
Serial.readBytes( ( char*)(&leds2[g]), 3);
}
for (g = 0; g < NUM_LEDS; g++) { //then we read the next 300 bytes for the third arc of LEDs
Serial.readBytes( ( char*)(&leds3[g]), 3);
}
for (g = 0; g < NUM_LEDS; g++) { //then we read the next 300 bytes for the fourth arc of LEDs
Serial.readBytes( ( char*)(&leds4[g]), 3);
}
for (g = 0; g < NUM_LEDS; g++) { //then we read the next 300 bytes for the fifth arc of LEDs
Serial.readBytes( ( char*)(&leds5[g]), 3);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// Let's test if all the pixels work.
// This will be too fast for real discernment but they should all be on at end of this
FastLED.clear();
for (int channelIndex = 0; channelIndex < NUM_LEDS; channelIndex++) {
leds1[channelIndex] = CRGB::Red;
FastLED.show();
}
delay(500);
for (int channelIndex = 0; channelIndex < NUM_LEDS; channelIndex++) {
leds2[channelIndex] = CRGB::Red;
FastLED.show();
}
delay(500);
for (int channelIndex = 0; channelIndex < NUM_LEDS; channelIndex++) {
leds3[channelIndex] = CRGB::Red;
FastLED.show();
}
delay(500);
for (int channelIndex = 0; channelIndex < NUM_LEDS; channelIndex++) {
leds4[channelIndex] = CRGB::Red;
FastLED.show();
}
delay(500);
for (int channelIndex = 0; channelIndex < NUM_LEDS; channelIndex++) {
leds5[channelIndex] = CRGB::Red;
FastLED.show();
}
delay(2000); // slight pause to check all on
FastLED.clear();
FastLED.show();
}
</nowiki>

Arduino

2020-10-19T02:51:32Z

MikeKrebs: added pixel code

Arduino Table of Contents

* [[Arduino and the mechanical relay]]

* [[Arduino and pixels V1]]

* yet another new page

File:Hanging Rod and Hook2.jpg

2020-04-30T04:51:30Z

MikeKrebs:

File:Turning Mech Underside2.jpg

2020-04-30T04:49:45Z

MikeKrebs:

File:Internal view of the Slow Rotate Servo and Ball Race Mounting3.jpg

2020-04-30T04:49:16Z

MikeKrebs: Internal view of the slow rotate servo and ball race mounting

Internal view of the slow rotate servo and ball race mounting

Super-sized Animatronic Ball Ornaments

2020-04-30T04:43:54Z

MikeKrebs: Features

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Watch The Video! Click HERE] - from Tory Street Lights'''

[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The ornament is handmade polyester resin over fiberglass and cheesecloth with animatronic eyes, eyelids, eyebrows and mouth.

'''How did it go over?'''
Maybe you want to make a splash in your display? Terry said, ''"With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public."''

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this: [https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch. He custom designed the ornaments and made them by hand. He thinks it was about a three month journey and they each turned out to be quite expensive ([[#Cost]]).

This entry was edited by MikeKrebs but most of it is Terry's words either from the video or from correspondence with him. So, when you read first person comments, you should hear Terry talking and when you read third person comments, that would be Mike putting words to Terry's project. If you make something similar and want to add your comments, please do so!
== Features ==
*Large ornament - about 2 feet across
*Sculpted eye sockets
*Eyes move together for natural look
*Eye moves in two dimensions - up/down and left-right
*Eye movements can be done at same time (roll eyes!)
*Eyebrows are independently controlled
*Ornament turns away from crowd when not doing show
*Controlled via Renard protocol
*Can be controlled by wireless ESP8266 module
*All custom made

== Bill of Materials ==

*Big ball (25 inches)
*PVA glue (Elmers!)
*Paper towels for mache
*Cheesecloth
*Fiberglass and polyester resin
*Bog filler (Bondo type could be used) to form up eye contours
*Planting container

For the record there are eight servos in use in each ornament.
*1 - Mouth
*2 - Slow Rotate
*3 - Eyes Up / Down
*4 - Eyes Left / Right
*5 - Left Eyelid
*6 - Right Eyelid
*7 - Left Eye Brow
*8 - Right Eyebrow

The individual control of the eyelids was so that I could make them wink, while the separate eyebrows were also for expression / effect.
*There is also a motor that turns the whole assembly.

*brass rods
*wire rods
*bicycle spokes
*foam board
*board board

*Renard board
*Renard servo software
*Opto-couplers
*Drivers

*1000 watt slide projector with template

*Chris Maloney's Audacity converter.

*Many cans of paint.

== Eye Mechanism ==
The inspiration was [https://www.youtube.com/watch?v=6jqvu_MQ5pc Marshall Tearle's Eyes]. If you look his over, you will see how Tory Street Light's came together.

Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

== Ornament Mounting ==
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

== Ornament Rotation ==
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

Here you can see the gears including the limit switches and the stop bolt that provide the stop position for "Off" and "On".
[[FILE:Complete_view_of_Turning_Mech_fromTop2.jpg]]

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

== Renard controller ==
[[FILE:32_Channel_Ren_Servo_Controller_Box2.jpg]]

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed electric drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain. The Renard controller talks to the opto-couplers via the cable bundles on the right side of the case.

The Renservo software came from Dirk’s Wiki, originally written by “GDYRDAVE”, who passed away a couple of years ago, and updated by Chris Maloney, “Ctmal” on the forum :-

[[Firmware_-_multiple_versions]]

I used the Pic16F688 version which worked fine for me. I tried the PIC 16F1825 version, this worked fine but inverted the data/servo positions and as such I didn’t have the time to correct all the data so I returned to the PIC16F688.

== Opto-coupler and buffer box ==
[[FILE:32_Channel_Ren_Servo_Opto_Buffer_and_Gating_Box2.jpg]]

The Opto-coupler and buffer box also has 32 channels available. The opto-couplers are wired to the buffer chips that send the signals to the servos and relays. The buffer/driver chips are hidden under the linking cables on the right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a Renard controller channel, applied through an opto-coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence.

== Cost ==
The whole project took around three months or so, full time. Thankfully I am retired; so time is not too much of a problem. I did not have a budget for the project. It just had a life of its own, and as it transpired, it was a good thing I didn’t. Only when the project was completed I managed to locate all the invoices / till dockets and totaled them up. It was a good thing I was sitting down when I saw the bottom line!! They cost around $600.00 (US) each, way above my guestimation!! With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public.

The most expensive items would be the Fiberglass Dynal Cloth, Polyester Resin and the thinners. Then the Rustoleum Glitter spray-can paint, these were about $20.00 (US) per can and I used around 10 per Ornament. Also about 8 or 10 Cans of clear sealing spray, thankfully slightly cheaper than the Glitter paint! Next in line would be the several pounds of Polyester builders / car body filler or “Bog” that was required to form/create the eyebrows and eye sockets. The next most expensive would be the big Jumbo servos, they were around the $30.00 – $40.00 each, two per ornament, plus spares, as well as the very fast eyelid servo’s they were in the region of $15.00 each with two per Ornament, plus spares.

It was fortuitous that I was able to acquire from my employer, prior to retirement, discarded, out of spec, Ball races, big gears, micro switches and the industrial plastic parts that I used to create the eye mechanism. The ball races, (8 per ornament) and the mounting plates that support the ornaments are included in the above!

Super-sized Animatronic Ball Ornaments

2020-04-24T04:55:18Z

MikeKrebs: Getting there - added more content

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Watch The Video! Click HERE] - from Tory Street Lights'''

[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The ornament is handmade polyester resin over fiberglass and cheesecloth with animatronic eyes, eyelids, eyebrows and mouth.

'''How did it go over?'''
Maybe you want to make a splash in your display? Terry said, ''"With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public."''

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this:

[https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch. He custom designed the ornaments and made them by hand. He thinks it was about a three month journey and they each turned out to be quite expensive ([[#Cost]]).

This entry was edited by MikeKrebs but most of it is Terry's words either from the video or from correspondence with him. So, when you read first person comments, you should hear Terry talking and when you read third person comments, that would be Mike putting words to Terry's project. If you make something similar and want to add your comments, please do so!

== Bill of Materials ==

*Big ball (25 inches)
*PVA glue (Elmers!)
*Paper towels for mache
*Cheesecloth
*Fiberglass and polyester resin
*Bog filler (Bondo type could be used) to form up eye contours
*Planting container

For the record there are eight servos in use in each ornament.
*1 - Mouth
*2 - Slow Rotate
*3 - Eyes Up / Down
*4 - Eyes Left / Right
*5 - Left Eyelid
*6 - Right Eyelid
*7 - Left Eye Brow
*8 - Right Eyebrow

The individual control of the eyelids was so that I could make them wink, while the separate eyebrows were also for expression / effect.
*There is also a motor that turns the whole assembly.

*brass rods
*wire rods
*bicycle spokes
*foam board
*board board

*Renard board
*Renard servo software
*Opto-couplers
*Drivers

*1000 watt slide projector with template

*Chris Maloney's Audacity converter.

*Many cans of paint.

== Eye Mechanism ==
The inspiration was [https://www.youtube.com/watch?v=6jqvu_MQ5pc Marshall Tearle's Eyes]. If you look his over, you will see how Tory Street Light's came together.

Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

== Ornament Mounting ==
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

== Ornament Rotation ==
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

Here you can see the gears including the limit switches and the stop bolt that provide the stop position for "Off" and "On".
[[FILE:Complete_view_of_Turning_Mech_fromTop2.jpg]]

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

== Renard controller ==
[[FILE:32_Channel_Ren_Servo_Controller_Box2.jpg]]

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed electric drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain. The Renard controller talks to the opto-couplers via the cable bundles on the right side of the case.

The Renservo software came from Dirk’s Wiki, originally written by “GDYRDAVE”, who passed away a couple of years ago, and updated by Chris Maloney, “Ctmal” on the forum :-

[[Firmware_-_multiple_versions]]

I used the Pic16F688 version which worked fine for me. I tried the PIC 16F1825 version, this worked fine but inverted the data/servo positions and as such I didn’t have the time to correct all the data so I returned to the PIC16F688.

== Opto-coupler and buffer box ==
[[FILE:32_Channel_Ren_Servo_Opto_Buffer_and_Gating_Box2.jpg]]

The Opto-coupler and buffer box also has 32 channels available. The opto-couplers are wired to the buffer chips that send the signals to the servos and relays. The buffer/driver chips are hidden under the linking cables on the right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a Renard controller channel, applied through an opto-coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence.

== Cost ==
The whole project took around three months or so, full time. Thankfully I am retired; so time is not too much of a problem. I did not have a budget for the project. It just had a life of its own, and as it transpired, it was a good thing I didn’t. Only when the project was completed I managed to locate all the invoices / till dockets and totaled them up. It was a good thing I was sitting down when I saw the bottom line!! They cost around $600.00 (US) each, way above my guestimation!! With the benefit of hindsight that was money well spent, judging from the comments that I hear from the viewing public.

The most expensive items would be the Fiberglass Dynal Cloth, Polyester Resin and the thinners. Then the Rustoleum Glitter spray-can paint, these were about $20.00 (US) per can and I used around 10 per Ornament. Also about 8 or 10 Cans of clear sealing spray, thankfully slightly cheaper than the Glitter paint! Next in line would be the several pounds of Polyester builders / car body filler or “Bog” that was required to form/create the eyebrows and eye sockets. The next most expensive would be the big Jumbo servos, they were around the $30.00 – $40.00 each, two per ornament, plus spares, as well as the very fast eyelid servo’s they were in the region of $15.00 each with two per Ornament, plus spares.

It was fortuitous that I was able to acquire from my employer, prior to retirement, discarded, out of spec, Ball races, big gears, micro switches and the industrial plastic parts that I used to create the eye mechanism. The ball races, (8 per ornament) and the mounting plates that support the ornaments are included in the above!

Super-sized Animatronic Ball Ornaments

2020-04-23T05:12:22Z

MikeKrebs: added some more pictures

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Click HERE] - from Tory Street Lights'''
[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The general ideas for how to put them together is valid for any similar item you want to make.

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this:

[https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch.

'''Bill of Materials'''

Big ball (25 inches)
PVA/paper
Cheesecloth
Fiberglass and poly

Planting container

Servos of various sizes
4 servos for the eyes.
2 servos for the eyebrows
1 servo for the mouth.
1 motor and gears for the ornament to turn away from crowd when not performing

brass rods
wire rods
foam board
board board

Renard board
Optocouplers
Drivers

1000 watt slide projector with template

Chris Maloney's Audacity

Many cans of paint.

'''Some further comments about the "Supersized Christmas Balls" to clarify some points about the project may be in order.'''
'''Eye Mechanism'''
Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

'''Ornament Mounting'''
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

'''Ornament Rotation'''
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

Here you can see the gears including the limit switches and the stop bolt that provide the stop position for "Off" and "On".
[[FILE:Complete_view_of_Turning_Mech_fromTop2.jpg]]

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

'''Renard controller'''
[[FILE:32_Channel_Ren_Servo_Controller_Box2.jpg]]

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed electric drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain. The Renard controller talks to the opto-couplers via the cable bundles on the right side of the case.

'''Opto-coupler and buffer box'''
[[FILE:32_Channel_Ren_Servo_Opto_Buffer_and_Gating_Box2.jpg]]

The Opto-coupler and buffer box also has 32 channels available. The opto-couplers are wired to the buffer chips that send the signals to the servos and relays. The buffer/driver chips are hidden under the linking cables on the right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a Renard controller channel, applied through an opto-coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence,

File:Complete view of Turning Mech fromTop2.jpg

2020-04-23T05:03:29Z

MikeKrebs:

File:32 Channel Ren Servo Opto Buffer and Gating Box2.jpg

2020-04-21T04:33:11Z

MikeKrebs:

File:32 Channel Ren Servo Controller Box2.jpg

2020-04-21T04:30:44Z

MikeKrebs:

Super-sized Animatronic Ball Ornaments

2020-04-21T04:28:01Z

MikeKrebs:

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Click HERE] - from Tory Street Lights'''
[[File:Expressions 3.jpg]]

'''What is it?'''
These are lip-syncing ornaments. The general ideas for how to put them together is valid for any similar item you want to make.

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this:

[https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch.

'''Bill of Materials'''

Big ball (25 inches)
PVA/paper
Cheesecloth

Planting container

Servos of various sizes
4 servos for the eyes.
2 servos for the eyebrows
1 servo for the mouth.
1 motor and gears for the ornament to turn away from crowd when not performing

brass rod
foam board

Renard board
Optocouplers
Drivers

1000 watt slide projector with template

Chris Maloney's Audacity

Many cans of paint.

'''Some further comments about the "Supersized Christmas Balls" to clarify some points about the project may be in order.'''
'''Eye Mechanism'''
Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits (denatured alcohol), then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

'''Ornament Mounting'''
Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adapter screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eye-bolt in the same plates, this eye-bolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

'''Ornament Rotation'''
The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

'''Renard controller'''
Another item that may require further explanation is the Renard controller. This is housed in a re-purposed Electric Drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a strip-board 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain.

The Opto-coupler and buffer box also has 32 channels available, with the buffer/driver chips hidden under the linking cables on the Right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a display Renard controller channel, applied through an opto coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence,

File:Expressions 3.jpg

2020-04-21T04:17:11Z

MikeKrebs: Supersize ornaments

Supersize ornaments

Super-sized Animatronic Ball Ornaments

2020-04-21T03:56:12Z

MikeKrebs: Added content from Terry

:* '''Supersized Animatronic Christmas Ball Ornament - [https://www.youtube.com/watch?v=i6EUMGoU_6s&feature=youtu.be Click HERE] - from Tory Street Lights'''

More below...

'''What is it?'''
These are lip-syncing ornaments. The idea for how to put them together is valid for any similar item you want to make.

'''Where did this idea come from?'''
Brian "Lightman" Lincoln did this:

[https://player.vimeo.com/video/148903061 Singing Christmas Tree]

Terry Sutton (Tory Street Lights aka T.D.Sutton) wanted to supersize the idea for his front porch.

'''Bill of Materials'''

Big ball (25 inches)
PVA/paper
Cheesecloth

Planting container

Servos of various sizes
4 servos for the eyes.
2 servos for the eyebrows
1 servo for the mouth.
1 motor and gears for the ornament to turn away from crowd when not performing

brass rod
foam board

Renard board
Optocouplers
Drivers

1000 watt slide projector with template

Chris Maloney's Audacity

Many cans of paint.

'''Some further comments about the "Supersized Christmas Balls" to clarify some points about the project may be in order.'''

Setting up the eye mechanism required an inordinate amount of time. Placing the eyeball mounting rod with the universal joint exactly in the geometric center of the ball required a center mark to be made on the outside of the ball with a black marker pen while the ball half was spun up in my metal lathe to locate the eye center. A 1/8 inch brass rod, with a washer soldered on the end, roughly shaped to a convex curve to match the internal surface of the ball, was then "5 minute Epoxied" into the ball. The rod was located over the ball's center mark, while being held at the outside end by the centering plate. The brass rod was then cut to length once the Epoxy had cured.

This was centering was most important, as the eyeball had to be concentric with the eyelids to allow them to open and close with the eyeballs in any position, but not touch one-another. The clearances involved in this project were very fine and created problems when I glued the photograph of the eye in position. Many hours of adjustment was required to get everything operating and in the correct place.

The pictures of real eyes, obtained from the internet, were adjusted to the required size and then printed as photographs in a local photo lab. They were cut to shape and then had three radial cuts made in to the black iris. To make them to conform to the eye's spherical form they were soaked in Methylated spirits, then pressed between waste disk sections removed from the rear of the eyeball when it was opened up for mounting and control.

The eye mechanism in the photographs is a spare set, and as such has micro servos to operate the eyelids, the display ornaments have digital servos in that position that are three or four times faster. These were necessary because human eyelids "Blink" very quickly, to replicate this, super fast servos were required.

Each "Ball" is supported on a 3/8 inch threaded rod running through ball races mounted under the two marine ply plates that are fiber-glassed inside the ball. The weight is taken on nuts threaded on the rod with two nuts locked together at the bottom, and another pair under, and on top of, the top bearing. At the bottom, inside the ball, an arm is lock-nutted to the rod, which is connected to an arm on a jumbo servo to allow slow controlled rotation of the ball, over about 60 degrees, so that they can "look" at each other.

The top end of the rod has a purpose made threaded female adaptor screwed on and lock-nutted to it that converts from 3/8 inch to 6.0 mm. The 6.0 mm socket end has a 6.00 mm threaded "Rawl Anchor" hook that is made for concrete "Rawl Anchor" attachments. These were used because I did not trust my welding should I welded the two rods together.

The hook is simply hooked over a bolt running through two plates that are bolted through another eyebolt in the same plates, this eyebolt is attached to the 180 degree rotating mechanism in a similar way to the ball's hook. This setup is visible in the picture under the rotating mechanism. Once the ball is hooked onto its cross bolt, the bolts are tightened up very tight, because all the rotating forces are transferred through the fixture. The hook makes for "easy" mounting and demounting of the Ball.

The rotating mechanism may require some further explanation, it is based on a 24 volt gearbox out of a soft drink dispenser, or similar. It has another three times reduction to it's output shaft using some discarded heavy duty gears from my work at the time. The 3/8 inch threaded output shaft is once more supported on ball races top and bottom, lock nutted as required. The large output gear has bolts on it to operate the Micro switch end-stops. Electrically the mechanism has 12 volts DC supplied permanently, and is controlled by a signal from one of the display Renard controller channels. When the channel is "Off" the ball is "Parked", when the channel is "On" the ball rotates 180 degrees and faces the street, then returns to parked again when the channel is switched "Off".

The Rotating mechanism is mounted on a discarded satellite dish mounting arm, locked up good and tight at right angles. The arm is attached to a wooden plate that is "F" cramped to a verandah rafter when on display. This plate has hooks to slip under the iron roof for added support. The result being the balls are kept out of the weather for protection, and out of sight when not "Performing".

Another item that may require further explanation is the Renard controller. This is housed in a re-purposed Electric Drill case, with the electronics separated inside plastic sandwich boxes for safety. The controller is a stripboard 32 channel Renard controller, using regular PIC16F688 chips, loaded with Chris Maloney's Ren Servo software, running at 11500 baud. There are 32 Channels because it was initially intended to have four "Ornaments". The controller is capable of running from the ESP8266 Pixelstick in the lower lefthand corner of the picture, but I prefer it to be cabled from the end of a 448 Channel controller chain.

The Opto-coupler and buffer box also has 32 channels available, with the buffer/driver chips hidden under the linking cables on the Right hand side of the picture. It was fortuitous that the buffer chips have a tri-state gating pin. I was able to take advantage of this to disable the data to the Ornaments when they were not "Performing". This was necessary because the Renard chain was outputting pulse width data outside the range of the servos when not "performing", the effect was that all the servos went to random positions way outside their expected positions. The gating signal was gained by using the projector control signal from a display Renard controller channel, applied through an opto coupler. The gating to "On" occurs 100 milliseconds after the start of the sequence, and "Off" occurs 60 milliseconds before the end of the sequence,

Super-sized Animatronic Ball Ornaments

2020-04-20T05:30:19Z

MikeKrebs: Started putting Wiki entry together

Arduino and the mechanical relay using Renard

2018-08-04T05:01:56Z

MikeKrebs: Start

Okay! Maybe you started with generic serial but noticed that most DIY controllers are using the Renard protocol. We have a sketch for that!
Renard is a version of a serial protocol. What makes it Renard is that it has a built-in sync byte, start addresses, and escaped values for the values used for those things. Bill Porter (madsci1016) wrote a small library that handles the protocol so the base code becomes very easy.

You get the library here: [https://github.com/madsci1016/Arduino-Renard Renard Protocol]

Once you have it downloaded, just load it using Sketch/Include Library/Add .ZIP Library.

Having a library for the bringing in the serial data makes the program really simple. In the loop(), all we do is wait until we have filled the buffer and then we turn on/off lights.

Arduino and the mechanical relay

2018-08-04T03:51:00Z

MikeKrebs:

So you bought an arduino and then you got one of those cheap relay boards and you decided to try to do blinky flashy with them. First, it is not a great idea but assuming you want to try it, here you go!

== Second, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Basically Vixen "generic" serial mechanical relay sketch
// - Setup a generic serial controller to use this sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const long SERIAL_COM_SPEED = 115200L;
This sets the communication speed back to the player. This will have to match the controller setup in your player. 115,200 baud is equivalent to 115,200 bps which translates to:
115,200 / 8 bits of data plus 2 bits of overhead = 11,520 bytes per second
11,520 bytes / 20 fps (50 ms) = 576 bytes per frame

This is way more than enough for this setup but this becomes more important when we start doing pixels. So, we might as well use the faster speed.

const int CONTROLLER_HEADER[3] = {33, 34, 35};
This is how we find the beginning of a packet. This is also set in the controller setup in the player. The player will send these bytes before sending the data bytes. We define them in integer so consult an ASCII chart to find the appropriate values. Using three values and using values that are one digit apart will make it hard to accidentally send these values. The reason we do this is because the communication stream could be interrupted and this will re-sync the stream. This also means that if something is wrong with your lights, you can fix it, turn the power back on and it will find which lights to turn on in order.

const int ON = LOW;
const int OFF = HIGH;
Most mechanical relays turn on when we send off (LOW or x'00'). If your relays are off when they should be on (and on when they should be off), then you will need to flip the LOW and HIGH.

Everything else in this sketch should just work with generic serial controller. As of June, 2018, this limits you to Vixen 2 or Vixen 3. If you need a Renard sketch, see [[Arduino and the mechanical relay using Renard]].

Arduino and the mechanical relay

2018-07-02T03:15:00Z

MikeKrebs:

So you bought an arduino and then you got one of those cheap relay boards and you decided to try to do blinky flashy with them. First, it is not a great idea but assuming you want to try it, here you go!

== Second, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Basically Vixen "generic" serial mechanical relay sketch
// - Setup a generic serial controller to use this sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const long SERIAL_COM_SPEED = 115200L;
This set the communication speed back to the player. This will have to match the controller setup in your player. 115,200 baud is equivalent to 115,200 bps which translates to:
115,200 / 8 bits of data plus 2 bits of overhead = 11,520 bytes per second
11,520 bytes / 20 fps (50 ms) = 576 bytes per frame

This is way more than enough for this setup but this becomes more important when we start doing pixels. So, we might as well use the faster speed.

const int CONTROLLER_HEADER[3] = {33, 34, 35};
This is how we find the beginning of a packet. This is also set in the controller setup in the player. The player will send these bytes before sending the data bytes. We define them in integer so consult an ASCII chart to find the appropriate values. Using three values and using values that are one digit apart will make it hard to accidentally send these values. The reason we do this is because the communication stream could be interrupted and this will re-sync the stream. This also means that if something is wrong with your lights, you can fix it, turn the power back on and it will find which lights to turn on in order.

const int ON = LOW;
const int OFF = HIGH;
Most mechanical relays turn on when we send off (LOW or x'00'). If your relays are off when they should be on (and on when they should be off), then you will need to flip the LOW and HIGH.

Everything else in this sketch should just work with generic serial controller. As of June, 2018, this limits you to Vixen 2 or Vixen 3. If you need a Renard sketch, see [[Arduino and the mechanical relay using Renard]].

Arduino and the mechanical relay

2018-07-02T03:14:03Z

MikeKrebs:

So you bought an arduino and then you got one of those cheap relay boards and you decided to try to do blinky flashy with them. First, it is not a great idea but assuming you want to try it, here you go!

== First, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Basically Vixen "generic" serial mechanical relay sketch
// - Setup a generic serial controller to use this sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const long SERIAL_COM_SPEED = 115200L;
This set the communication speed back to the player. This will have to match the controller setup in your player. 115,200 baud is equivalent to 115,200 bps which translates to:
115,200 / 8 bits of data plus 2 bits of overhead = 11,520 bytes per second
11,520 bytes / 20 fps (50 ms) = 576 bytes per frame

This is way more than enough for this setup but this becomes more important when we start doing pixels. So, we might as well use the faster speed.

const int CONTROLLER_HEADER[3] = {33, 34, 35};
This is how we find the beginning of a packet. This is also set in the controller setup in the player. The player will send these bytes before sending the data bytes. We define them in integer so consult an ASCII chart to find the appropriate values. Using three values and using values that are one digit apart will make it hard to accidentally send these values. The reason we do this is because the communication stream could be interrupted and this will re-sync the stream. This also means that if something is wrong with your lights, you can fix it, turn the power back on and it will find which lights to turn on in order.

const int ON = LOW;
const int OFF = HIGH;
Most mechanical relays turn on when we send off (LOW or x'00'). If your relays are off when they should be on (and on when they should be off), then you will need to flip the LOW and HIGH.

Everything else in this sketch should just work with generic serial controller. As of June, 2018, this limits you to Vixen 2 or Vixen 3. If you need a Renard sketch, see [[Arduino and the mechanical relay using Renard]].

Arduino and the mechanical relay

2018-07-02T03:05:04Z

MikeKrebs: Update the things you might want to change

== First, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Basically Vixen "generic" serial mechanical relay sketch
// - Setup a generic serial controller to use this sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen, xLights or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen or in model definition in xLights. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const long SERIAL_COM_SPEED = 115200L;
This set the communication speed back to the player. This will have to match the controller setup in your player. 115,200 baud is equivalent to 115,200 bps which translates to:
115,200 / 8 bits of data plus 2 bits of overhead = 11,520 bytes per second
11,520 bytes / 20 fps (50 ms) = 576 bytes per frame

This is way more than enough for this setup but this becomes more important when we start doing pixels. So, we might as well use the faster speed.

const int CONTROLLER_HEADER[3] = {33, 34, 35};
This is how we find the beginning of a packet. This is also set in the controller setup in the player. The player will send these bytes before sending the data bytes. We define them in integer so consult an ASCII chart to find the appropriate values. Using three values and using values that are one digit apart will make it hard to accidentally send these values. The reason we do this is because the communication stream could be interrupted and this will re-sync the stream. This also means that if something is wrong with your lights, you can fix it, turn the power back on and it will find which lights to turn on in order.

const int ON = LOW;
const int OFF = HIGH;
Most mechanical relays turn on when we send off (LOW or x'00'). If your relays are off when they should be on (and on when they should be off), then you will need to flip the LOW and HIGH.

Everything else in this sketch should just work with generic serial controller. As of June, 2018, this limits you to Vixen 2 or Vixen 3. If you need a Renard sketch, see Arduino and the mechanical relay using Renard.

Arduino and the mechanical relay

2018-07-02T00:57:10Z

MikeKrebs:

== First, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Vixen/xLights "generic" serial mechanical relay sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen/xLights information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen, xLights or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen or in model definition in xLights. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const long SERIAL_COM_SPEED = 115200L;

const int CONTROLLER_HEADER[3] = {33, 34, 35};
const int ON = LOW;
const int OFF = HIGH;

Arduino and the mechanical relay

2018-07-02T00:54:53Z

MikeKrebs:

== First, here's the program code -- comments follow later! ==

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Vixen/xLights "generic" serial mechanical relay sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen/xLights information
// speed for the com port for talking with player
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int CONTROLLER_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in sequencer)

// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(CONTROLLER_HEADER) / sizeof(int); // no need to change
const int CHANNEL_COUNT = sizeof(channels) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForControllerHeader(CONTROLLER_HEADER);
readSequenceData();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readSequenceData()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForControllerHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the CONTROLLER_HEADER byte
int inByte = Serial.read();
if (inByte != CONTROLLER_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}

</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen, xLights or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen or in model definition in xLights. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const int CHANNEL_COUNT = 8;
const long SERIAL_COM_SPEED = 115200L;
const int VIXEN_HEADER[3] = {33, 34, 35};
const int ON = LOW;
const int OFF = HIGH;

Arduino and the mechanical relay

2018-06-23T05:12:25Z

MikeKrebs: /* Things you might have to change */

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Vixen/xLights "generic" serial mechanical relay sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// - CHANNEL_COUNT is number of channels it will listen for from Vixen
const int CHANNEL_COUNT = 8;
// speed for the com port for talking with vixen
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int VIXEN_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in Vixen sequence)
// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(VIXEN_HEADER) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);
Serial.write("Setup");

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForVixenHeader(VIXEN_HEADER);
readFromVixen();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readFromVixen()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForVixenHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the VIXEN_HEADER byte
int inByte = Serial.read();
if (inByte != VIXEN_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}
</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen, xLights or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels". The order of definition is the order the pins will be turned on or off. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. This is done in the element to controller mapping in Vixen or in model definition in xLights. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const int CHANNEL_COUNT = 8;
const long SERIAL_COM_SPEED = 115200L;
const int VIXEN_HEADER[3] = {33, 34, 35};
const int ON = LOW;
const int OFF = HIGH;

Arduino and the mechanical relay

2018-06-23T05:08:31Z

MikeKrebs: Started explaining the code

<nowiki>
// *** diychristmas.org free software so long as this line remains in sketch!
// Vixen/xLights "generic" serial mechanical relay sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// - CHANNEL_COUNT is number of channels it will listen for from Vixen
const int CHANNEL_COUNT = 8;
// speed for the com port for talking with vixen
const long SERIAL_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int VIXEN_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in Vixen sequence)
// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(VIXEN_HEADER) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(SERIAL_COM_SPEED);
Serial.write("Setup");

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForVixenHeader(VIXEN_HEADER);
readFromVixen();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readFromVixen()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForVixenHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the VIXEN_HEADER byte
int inByte = Serial.read();
if (inByte != VIXEN_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}
</nowiki>

Let's talk about the code...
At the top of the sketch, you will find the definitions of how you are going to use the Arduino with Vixen, xLights or any other serial output. These things are self explanatory but for the "I've never seen an Arduino or Vixen setup" people, here is another try to explain them.

== Things you might have to change ==

int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

This line assigns pins from the arduino to specific "channels" in order. In your software, you would assign channel one to Shrub1, channel two to Shrub2, etc. You will need to map these through the Arduino pins to the specific relay on your relay board and out to the lights.
It might look like this:
{| class="wikitable"
|-
! scope="col"| Description
! scope="col"| Channel
! scope="col"| Pin
! scope="col"| Relay
|-
| Shrub1Left
| style="text-align:center;" | 1
| style="text-align:center;" | 2
| style="text-align:center;" | In1
|-
| Shrub2
| style="text-align:center;" | 2
| style="text-align:center;" | 3
| style="text-align:center;" | In2
|-
| Shrub3
| style="text-align:center;" | 3
| style="text-align:center;" | 4
| style="text-align:center;" | In3
|-
| Shrub4Right
| style="text-align:center;" | 4
| style="text-align:center;" | 5
| style="text-align:center;" | In4
|-
| Post1Left
| style="text-align:center;" | 5
| style="text-align:center;" | 6
| style="text-align:center;" | In5
|-
| Post2
| style="text-align:center;" | 6
| style="text-align:center;" | 7
| style="text-align:center;" | In6
|-
| Post3
| style="text-align:center;" | 7
| style="text-align:center;" | 8
| style="text-align:center;" | In7
|-
| Post4Right
| style="text-align:center;" | 8
| style="text-align:center;" | 10
| style="text-align:center;" | In8
|}

const int CHANNEL_COUNT = 8;
const long VIXEN_COM_SPEED = 115200L;
const int VIXEN_HEADER[3] = {33, 34, 35};
const int ON = LOW;
const int OFF = HIGH;

Arduino and the mechanical relay

2018-06-22T03:51:57Z

MikeKrebs: Add code to page

<nowiki>
// Vixen/xLights generic serial mechanical relay sketch
// - Uses digitalWrite as this outputs LOW or HIGH no pwm values
// - This is what is needed for a mechanical relay

// Hookup the relay in order of channel definition
// Define as many as you need
// put channels (pins) in an array so we can use looping structures to control
int channels[] = {2, 3, 4, 5, 6, 7, 8, 10};

// Vixen information
// - CHANNEL_COUNT is number of channels it will listen for from Vixen
const int CHANNEL_COUNT = 8;
// speed for the com port for talking with vixen
const long VIXEN_COM_SPEED = 115200L;
// Generic Serial controller config - must be present, must match controller setup
const int VIXEN_HEADER[3] = {33, 34, 35}; // This is character !"# (hard to replicate in Vixen sequence)
// Relays
// - most mechanical relays turn on when pin is low, off on high
const int ON = LOW;
const int OFF = HIGH;

// these are program variables we need to use in multiple places
const int SIZE_OF_HEADER = sizeof(VIXEN_HEADER) / sizeof(int); // no need to change
int buffer[CHANNEL_COUNT]; // no need to change going to hold relay output values

void setup()
{
Serial.begin(VIXEN_COM_SPEED);
Serial.write("Setup");

// set the channel pins to output mode
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
pinMode(channels[channelIndex], OUTPUT);
}

turnLightsOff();
powerOnSelfTest(); // watch your lights to make sure they are all going on in order
}

void loop()
{
waitForVixenHeader(VIXEN_HEADER);
readFromVixen();
outputToLights();
}

void turnLightsOff()
{
//turn them all off
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], OFF);
}
}

void outputToLights()
{
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
// we should only be seeing 255 and 0 but in case someone tried a fade
// 48 is used for debug purposes. You can use the serial monitor to test
// send this string !"#01010101 to turn on every other relay as 0 == dec(48) 1 == dec(49)
if (buffer[channelIndex] > 48) {
digitalWrite(channels[channelIndex], ON);
}
else {
digitalWrite(channels[channelIndex], OFF);
}
}
}

void readFromVixen()
{
char buffer2[CHANNEL_COUNT];
int index = 0;

while (Serial.available() < CHANNEL_COUNT) {}
// We have enough data!
for (int i = 0; i < CHANNEL_COUNT; i++) {
int inByte = Serial.read();
buffer[i] = inByte;
Serial.write(inByte);
}
}

void waitForVixenHeader(int header[])
{
for (int i = 0; i < SIZE_OF_HEADER; i++) {
// wait for serial available
while (!Serial.available()) {}
// Check the byte until it matches the VIXEN_HEADER byte
int inByte = Serial.read();
if (inByte != VIXEN_HEADER[i]) {
i = -1; // wrong data set to "zero"
}
}
// found the header!
}

// powerOnSelfTest - does a couple of checks to make sure everything turns on and off
// - watch your lights, they should go on in order
void powerOnSelfTest()
{
// This routines turns on and off each relay in order
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // turn on one channel at a time
delay(2000);
digitalWrite(channels[channelIndex], OFF);
}
// This routines turns on each relay in order leaving them all on for .5 seconds
for (int channelIndex = 0; channelIndex < CHANNEL_COUNT; channelIndex++) {
digitalWrite(channels[channelIndex], ON); // all on test
delay(500); // wait .5 seconds
}
delay(2000); // slight pause to check all on
turnLightsOff();
}
</nowiki>

Arduino

2018-06-22T03:35:37Z

MikeKrebs: Just getting started

Arduino Table of Contents

* [[Arduino and the mechanical relay]]

* another new page

* yet another new page