HOLIDAY MAGIC SYSTEMS BACKGROUND OF THE INVENTION The following includes information that may be useful in understanding the present invention(s). It is not an admission that any of the information provided herein is prior art, or material, to the presently described or claimed inventions, or that any publication or document that is specifically or implicitly referenced is prior art. 1. FIELD OF THE INVENTION [0001] The present invention relates generally to the field of rope lights and more specifically relates to a programmable light rope system. 2. DESCRIPTION OF RELATED ART ^[0002] Holidays and special occasions are often noticeably characterized by particular color themes. These color themes are seen in the color of various decorations, table cloths, and symbols that correspond to the particular occasions. In the last century, many of these color themes started becoming displayed in colored electric lights. For instance at Christmas time, a string of lights connected in series has been used to display the festive occasion using red, blue, green, orange, white, and yellow, and sometimes other colors as well. For Halloween, one might expect orange, yellow or amber, and purple. The colors may vary somewhat but overall generally follow a particular theme. The lights most often are displayed outdoors at night allowing the display to be seen from a considerable distance. One of the problems with the current lighting systems is that in order to change the color of the lights, the individual bulbs have to be unscrewed from the sockets and replaced with the BENSON_J.001U_JH

desired color of light bulbs. This is generally too time consuming for the average consumer so multiple light strings for different occasions generally get purchased. Storing the lights and decorations after the occasion can also take up considerable space, something there is usually not an over abundance of. [0003] In recent years, rope lights were invented as an alternative to the string of lights. The“bulbs” or light emitting diodes used in most rope lights are tiny in comparison to the bulbs used in the sockets of string lights and have a much different appearance. Rope lights are used in ordinary decorating to accent particular areas of a living room, gathering room, or certain pieces of art as well as for display for various holidays. The same problem exists with rope lights that has existed for string lights in that different strings of lights have to be purchased to change the theme or that a rope light that is able to display more than one theme only has a very limited few themes it is capable of displaying. A change in the basic design that would allow a user to display an inexhaustible amount of user preferred themes would be welcomed. [0004] Several attempts have been made to solve the above-mentioned problems such as those found in U.S. Pat. No. 6,690,120 to Frank Joseph Oskorep, U.S. Pat No. 7,257,551 to Dennis Michael Kazar and Frank Joseph Oskorep; U.S. Pat No. 5,747,940 to Renato M. Openiano; U.S. Pat No. 7,139,617 to Frederick M. Morgan; U.S. Pat No. 6,424,096 to Donovan S. Lowe; U.S. Pat No. 7,726,839 to Tseng-Lu Chien; U.S. Pat No. 7,605,547 to Chee Yu Ng; U.S. Pat No.7,810,955 to Tomislav Stimac; U.S. Pat No.6,299,056 to Kiyohisa Oota; U.S. Pat No. 7,322,714 to Douglas John Barnett; U.S. Pat No. 7,736,019 to Junichi Shimada; U.S. Pat. No. 5,944,408 to George Tong; U.S. Pat. No. 6,860,007 to Li-Wen Liu; and U.S. Pat. No.6,394,623 to Pui-HingTsui. This art is representative of rope lights.

BENSON_J.001U_JH

[0005] With regard to U.S. Pat. No. 6,690,120 to Frank Joseph Oskorep, U.S. Pat No. 7,257,551 to Dennis Michael Kazar and Frank Joseph Oskorep, U.S. Pat No. 5,747,940 to Renato M. Openiano, and U.S. Pat No. 7,139,617 to Frederick M. Morgan, these disclosures teach holiday color schemes having a pre-programmed switch or button that will automatically combine certain colors together to make a holiday color scheme (such as July 4th with red, white, and blue with one button press or red and green for Christmas with another button press). [0006] With regard to U.S. Pat No. 6,424,096 to Donovan S. Lowe, U.S. Pat No. 7,726,839 to Tseng-Lu Chien, U.S. Pat No. 7,605,547 to Chee Yu Ng, U.S. Pat No. 7,810,955 to Tomislav Stimac, U.S. Pat No. 6,299,056 to Kiyohisa Oota, U.S. Pat No. 7,322,714 to Douglas John Barnett, U.S. Pat No. 7,736,019 to Junichi Shimada, U.S. Pat. No. 5,944,408 to George Tong, U.S. Pat. No. 6,860,007 to Li-Wen Liu, and U.S. Pat. No. 6,394,623 to Pui-HingTsui, these disclosures teach wiring schemes, remote control, and LED design and configuration. None of these disclosures are similar to the present invention. [0007] Therefore, none of the above inventions and patents, taken either singly or in combination, is seen to describe the invention as claimed. [0008] Preferably, a rope light should provide multiple user preferred lighting themes, and yet, would operate reliably and be manufactured at a modest expense. Thus, a need exists for a reliable programmable light rope system to avoid the above-mentioned problems.

BENSON_J.001U_JH

BRIEF SUMMARY OF THE INVENTION [0009] In view of the foregoing disadvantages inherent in the known rope light art, the present invention provides a novel programmable light rope system. The general purpose of the present invention, which will be described subsequently in greater detail, is to provide an inexhaustible amount of user preferred lighting variations that are changeable using a wireless remote. [00010] In stark contrast to the prior art, the present invention, Holiday Magic Systems, teaches the use of individual colors that may blend together all at once. In further contrast, Holiday Magic Systems is able to color separate popular color schemes into different styles of separation which substantially improves upon the aforementioned patents. Holiday Magic Systems teaches a unique wiring schematic with a unique purpose in forming a color chamber within the rope tube. Additionally, the remote control of Holiday Magic Systems is unique to use because the buttons being pressed are for the expressed purpose of the color separation mode settings and to add or remove colors instantly, and the LED design and configuration is unique to as to forming the color chamber and how it functions. [00011] The programmable light rope system of the Holiday Magic System preferably comprises a rope light assembly having a lighting tube with an inner volume, a first end, and a second end, a plurality of color chambers, a plurality of LEDs each having a front side and a back side, a positive wire, a negative wire, a plurality of color-control wires, a male cord cap and a female cord cap, a programmable light controller, a transmitter, a receiver, and a remote controller. [00012] The programmable LED color rope-light system comprises a rope light assembly that is useful for displaying a user defined light color and flash-rate combination to display at BENSON_J.001U_JH

holidays and user preferred events. The lighting tube may be a translucent flexible tube having an inner volume linearly deposed through the lighting tube from the first end to the second end with the first end located at an opposite end of the lighting tube from the second end. The lighting tube preferably comprises transparent flexible plastic so that an illuminated LED is able to be seen anywhere within a 360 degree angle of view. The lighting tube is also about 15 feet in length and houses an assembly of about 100 LEDs. A converter is used to convert an alternating current input voltage into direct current for illumination of the LEDs. The color-control wires together with a single LED in each color chamber are arranged to form a number 7-shaped profile. The LEDs are deposed perpendicularly to the linear axis of the lighting tube and the color-control wires are attached to one side of the LEDs and are angled diagonally downward to the opposite side of the next adjacent LED. This arrangement facilitates evenly viewing the lights from anywhere within a 360 degree angle and prevents unintentional color mixing. [00013] The rope light assembly is structured and arranged to couple at least two additional lighting tubes in series together, end to end, for a total length of about 45 feet having a total of 300 LEDs. The multiple color chambers are each arranged linearly in series throughout the inner volume of the lighting tube and are formed by a space between two successive LEDs. Each front side of each LED is directed toward the back side of the next successive LED. Since the front sides of the LEDs are able to illuminate brighter than the back sides of the LEDs it helps prevent blending of the colors with adjacent color chambers by the isolation structuring. Each LED is able to illuminate red, blue, or green, or to illuminate any combination of the three basic colors to blend colors and produce the appearance of other colors such as amber, orange, turquoise, or magenta. The shade of each blended color may also be adjusted by the percentage (from 0 to 100%) that each color is illuminated. BENSON_J.001U_JH

[00014] The rope light assembly is structured and arranged to maintain a color separation in a first user programmable setting, and alternately to blend the colors in a second user programmable setting. The rope light assembly is structured and arranged to have 4 color separation modes. Each respective color separation mode has a corresponding different spacing between like colors. For instance, if red, white, and blue is the particular theme to be used such as for the 4th of July, pressing the Red/On button once, red lights will be seen for 5 feet, white will be seen for 5 feet, and blue will be seen for 5 feet. Pressing the button again will space the color groupings to 2.5 feet long each. Pressing the button again will space the groupings to 1.25 feet long each, and pressing the button yet again will alternate the three colors to 1.5 inches apart with every consecutive LED a different color with the red, white, and blue pattern. [00015] The colors that the rope light assembly is able to display are red, green, blue, white, orange, yellow, warm white, purple, amber, turquoise, and magenta as well as varying shades of each. The various modes that are able to be selected with the rope light assembly are: color selection mode, color separation mode, effect mode, dimmer and fade mode, flash- rate mode, and auto mode. The rope light assembly is able to display at least one mode at a time selected from the group consisting of: solid, chaser, twinkle, random, strobe, fireworks, color fade, and rainbow. The flash-rate mode has 10 flash-rate speeds. The combination of modes and settings allow the user to select from over 44 million possible combinations. [00016] The positive wire is located linearly along one side of the inner volume of the lighting tube and the negative wire is located linearly along an opposing side from the positive wire within the inner volume of the lighting tube. The plurality of color-control wires are in communication with each corresponding LED and with the receiver. The male cord cap is non-removably attached to the first end of the lighting tube and is in BENSON_J.001U_JH

communication with the positive wire and the negative wire. The female cord cap is non- removably attached to the second end of the lighting tube and is in communication with the positive wire and the negative wire. The programmable light controller is in communication with the transmitter, and the transmitter is in wireless communication with the receiver. The remote controller is in wireless communication with the transmitter suitable for remote controlling of the programmable LED color rope-light system from a distance of up to 50 feet. The remote controller is structured and arranged to wirelessly control all programming functions of the programmable light controller via the buttons on the remote controller. The rope light assembly is useful for attaching the lighting tube to a user preferred structure and wirelessly programming a user defined number and combination of flashing colored light themes for display corresponding to every user preferred holiday event and user defined purpose. [00017] The programmable light rope system may be sold as a kit that includes: at least one rope light assembly having at least one programmable light controller, at least one transmitter, at least one receiver, at least one remote controller, and at least one set of user instructions. [00018] A method of using the programmable light rope system may comprise the steps of: attaching the lighting tube of the rope light assembly in a user preferred arrangement to a user preferred structure, coupling the receiver to the lighting tube and to an alternating current source, coupling the transmitter having a matching radio frequency and an integrally constructed programmable light controller to the alternating current source, programming the programmable light controller to a user preferred lighting theme, displaying the user preferred lighting theme, uncoupling the lighting tube, the receiver, and the transmitter from the alternating current source, and storing the rope light assembly. BENSON_J.001U_JH

[00019] The present invention holds significant improvements and serves as a programmable light rope system. For purposes of summarizing the invention, certain aspects, advantages, and novel features of the invention have been described herein. It is to be understood that not necessarily all such advantages may be achieved in accordance with any one particular embodiment of the invention. Thus, the invention may be embodied or carried out in a manner that achieves or optimizes one advantage or group of advantages as taught herein without necessarily achieving other advantages as may be taught or suggested herein. The features of the invention which are believed to be novel are particularly pointed out and distinctly claimed in the concluding portion of the specification. These and other features, aspects, and advantages of the present invention will become better understood with reference to the following drawings and detailed description.

BENSON_J.001U_JH

BRIEF DESCRIPTION OF THE DRAWINGS [00020] The figures which accompany the written portion of this specification illustrate embodiments and method(s) of use for the present invention, programmable light rope system, constructed and operative according to the teachings of the present invention. [00021] FIG. 1 shows a perspective view illustrating the number 7-shaped profile of the diode and wire configuration of the programmable light rope system according to an embodiment of the present invention. [00022] FIG. 2 is a perspective view illustrating a color chamber of the programmable light rope system according to an embodiment of the present invention of FIG.1. [00023] FIG. 3 is a perspective view illustrating color separation mode 01 of the programmable light rope system according to an embodiment of the present invention of FIGS.1-2. [00024] FIG. 4 is a perspective view illustrating color separation mode 02 of the programmable light rope system according to an embodiment of the present invention of FIGS.1-3. [00025] FIG. 5 is a perspective view illustrating color separation mode 03 of the programmable light rope system according to an embodiment of the present invention of FIGS.1-4. [00026] FIG. 6 is a perspective view illustrating color separation mode 04 of the programmable light rope system according to an embodiment of the present invention of FIGS.1-5. BENSON_J.001U_JH

[00027] FIG. 7 is a front elevation view of a remote controller of the programmable light rope system according to an embodiment of the present invention of FIGS. 1-6.

[00028] FIG. 8 is a flowchart illustrating a method of use for programmable light rope system according to an embodiment of the present invention of FIGS.1-7.

[00029] The various embodiments of the present invention will hereinafter be described in conjunction with the appended drawings, wherein like designations denote like elements.

BENSON_J.001U_JH

DETAILED DESCRIPTION [00030] As discussed above, embodiments of the present invention relate to a rope light and more particularly to a programmable light rope system as used to provide an inexhaustible amount of user preferred lighting variations that have a 360 degree clear view, and that are changeable using a wireless remote. [00031] Generally speaking, the programmable light rope system is a wirelessly operated rope light assembly having an LED rope light with a programmable light controller, a transmitter, a receiver, and a remote controller. The light rope is constructed with color chambers that are formed by the space between LEDs. The LEDs are positioned perpendicularly to the linear axis of and within the inner volume of the transparent tube and the color control wires diagonally connect the LEDs forming a 7-shaped profile within each color chamber, which prevents unintentional color mixing. The programmable light controller allows over 44 million possibilities of color and flashing combinations with 11 colors and multiple shades of each color. [00032] Referring to the drawings by numerals of reference there is shown in FIG. 1, a perspective view illustrating number 7-shaped profile 280 of LED(s) 170 and color-control wire 210 configuration of programmable light rope system 100 according to an embodiment of the present invention. [00033] Rope light assembly 110 is useful for attaching lighting tube 120 to a user preferred structure and wirelessly programming a user defined number and combination of flashing colored light themes for display corresponding to every user preferred holiday event and user defined purpose.

BENSON_J.001U_JH

[00034] Programmable light rope system 100 preferably comprises rope light assembly 110 that is useful for displaying a user defined light 290 color and flash-rate combination to display at holidays and user preferred events. Lighting tube 120 may be a translucent flexible tube having inner volume 130 linearly deposed through lighting tube 120 from first end 140 to second end 150 with first end 140 located at an opposite end of lighting tube 120 from second end 150. Lighting tube 120 preferably comprises a transparent flexible plastic so that an illuminated light emitting diode (led) 170 is able to be seen anywhere within a 360 degree angle of view. Color-control wires 210 together with a single led(s) 170 in each color chamber(s) 160 are arranged to form number 7-shaped profile 280. Programmable light rope system 100 preferably comprises rope light assembly 110 having lighting tube 120 with inner volume 130 and first end 140 and second end 150, a plurality of color chamber(s) 160, a plurality of led(s) 170 each having front side 180 and back side 190, positive wire 199, negative wire 200, a plurality of color-control wires 210, male cord cap 220 and female cord cap 230, programmable light controller 240, transmitter 250, receiver 260, and remote controller 270. Led(s) 170 are deposed perpendicularly to the linear axis of lighting tube 120 and color-control wires 210 are attached to one side of led(s) 170 and are angled diagonally downward to the opposite side of the next adjacent led 170. This arrangement facilitates evenly viewing lights 290 from anywhere within a 360 degree angle and prevents unintentional color mixing. Positive wire 199 may be located linearly along one side of inner volume 130 of lighting tube 120 and negative wire 200 may be located linearly along an opposing side from positive wire 199 within inner volume 130 of lighting tube 120. The plurality of color-control wires 210 are in communication with each corresponding led(s) 170 and with receiver 260.

BENSON_J.001U_JH

[00035] Referring now to FIG. 2, a perspective view illustrating color chamber(s) 160 of programmable light rope system 100 according to an embodiment of the present invention of FIG.1. [00036] The multiple color chamber(s) 160 are each arranged linearly in series throughout inner volume 130 of lighting tube 120 and are formed by a space between two successive LED(s) 170. Each front side 180 of each LED(s) 170 is directed toward back side 190 of the next successive LED(s) 170. Since front sides 180 of LED(s) 170 are able to illuminate brighter than back sides 190 of LED(s) 170 it helps prevent blending of the colors with adjacent color chamber(s) 160 by the isolation structuring. Each LED(s) 170 is able to illuminate red 300, blue 320, or green 310, or to illuminate any combination of the three basic colors to blend colors and produce the appearance of other colors such as amber, orange, turquoise, or magenta. The shade of each blended color may also be adjusted by the percentage (from 0 to 100%) that each color is illuminated. Each LED(s) 170 is capable of producing red 300, blue 320, and green 310 and adjusting the intensity of each color. [00037] Referring now to FIG. 3, a perspective view illustrating color separation mode 01 of programmable light rope system 100 according to an embodiment of the present invention of FIGS.1-2. [00038] Rope light assembly 110 is structured and arranged to couple at least two additional lighting tubes 120 in series together, end to end, for a total length of about 45 feet having a total of 300 LED(s) 170. Rope light assembly 110 is structured and arranged to maintain a color separation in a first user programmable setting, and alternately to blend the colors in a second user programmable setting. Rope light assembly 110 is also designed to have 4 color separation modes. Each respective color separation mode has a corresponding BENSON_J.001U_JH

different spacing between like colors. For instance, if red 300, white, and blue 320 is the particular theme to be used such as for the 4th of July, after entering color separation mode by pressing the red/on button once, pressing red/on button 299 again, red 300 lights will be seen for 5 feet, white will be seen for 5 feet, and blue 320 will be seen for 5 feet. Pressing red/on button 299 again will space the color groupings to 2.5 feet long each. Pressing red/on button 299 again will space the groupings to 1.25 feet long each, and pressing red/on button 299 yet again will alternate the three colors to 1.5 inches apart with every consecutive LED(s) 170 a different color with the red 300, white, and blue 320 pattern. [00039] Referring now to FIG. 4, a perspective view illustrating color separation mode 02 of programmable light rope system 100 according to an embodiment of the present invention of FIGS.1-3. [00040] The colors that rope light assembly 110 are able to display are red 300, green 310, blue 320, white, orange, yellow, warm white, purple, amber, turquoise, and magenta as well as varying shades of each. The various modes that are able to be selected with rope light assembly 110 are: color selection mode, color separation mode, effect mode, dimmer and fade mode, flash-rate mode, and auto mode. Rope light assembly 110 is able to display at least one mode at a time selected from the group consisting of: solid, chaser, twinkle, random, strobe, fireworks, color fade, and rainbow. The flash-rate mode has 10 flash-rate speeds. The combination of modes and settings allow the user to select from over 44 million possible combinations. To enter color separation mode 02, press red/on button 299 two times and the spacing between color groupings will be 2.5 feet long each.

BENSON_J.001U_JH

[00041] Referring now to FIG. 5, a perspective view illustrating color separation mode 03 of programmable light rope system 100 according to an embodiment of the present invention of FIGS.1-4. [00042] Enter color separation mode 03 by pressing red/on button 299 button three times after already being in color separation mode. The same color of lights 290 are grouped together for a length of 1.25 feet with each color grouping abutting together and repeating for the length of lighting tube 120. Effects mode can be added to the chosen color theme to flash nearly any conceived user preferred pattern. [00043] Male cord cap 220 is non-removably attached to first end 140 of lighting tube 120 and is in communication with positive wire 199 and negative wire 200. Female cord cap 230 is non-removably attached to second end 150 of lighting tube 120 and is in communication with positive wire 199 and negative wire 200. Male cord cap 220 and female cord cap 230 may also contain contacts for attaching color-control wires 210 to receiver 260 or may have a separate coupler for connecting color-control wires 210 to receiver 260. [00044] Referring now to FIG. 6, a perspective view illustrating color separation mode 04 of programmable light rope system 100 according to an embodiment of the present invention of FIGS.1-5. [00045] Enter color separation mode 04 by pressing red/on button 299, then pressing red/on button 299 four more times which illuminates every LED(s) 170 that are spaced 1.5 inches apart, a different color according to the chosen color pattern. When turning the system back off again, press the black/off button 330 to power down rope light assembly 110.

BENSON_J.001U_JH

[00046] Referring now to FIG. 7, a front elevation view of remote controller 270 of programmable light rope system 100 according to an embodiment of the present invention of FIGS.1-6. [00047] Programmable light controller 240 is in communication with transmitter 250, and transmitter 250 is in wireless communication with receiver 260. Remote controller 270 is in wireless communication with transmitter 250 suitable for remote controlling of programmable light rope system 100 from a distance of up to 50 feet. Remote controller 270 is designed to wirelessly control all programming functions of programmable light controller 240 via the buttons on remote controller 270. Functions that may be manipulated from remote controller 270 are brightness, on/off, color selection, effects modes, and flash speed. [00048] Programmable light rope system 100 may be sold as kit 450 comprising the following parts: at least one rope light assembly 110 having at least one programmable light controller 240, at least one transmitter 250, at least one receiver 260, at least one remote controller 270, and at least one set of user instructions. The kit has instructions such that functional relationships are detailed in relation to the structure of the invention (such that the invention can be used, maintained, or the like in a preferred manner). Programmable light rope system 100 may be manufactured and provided for sale in a wide variety of sizes and shapes for a wide assortment of applications. Upon reading this specification, it should be appreciated that, under appropriate circumstances, considering such issues as design preference, user preferences, marketing preferences, cost, structural requirements, available materials, technological advances, etc., other kit contents or arrangements such as, for example, including more or less components, customized parts, different color combinations, parts may be sold separately, etc., may be sufficient.

BENSON_J.001U_JH

[00049] Referring now to FIG. 8 showing a flowchart illustrating method of use 500 for programmable light rope system 100 according to an embodiment of the present invention of FIGS. 1-7. As shown, method of use 500 may comprise the steps of: step one 501, attaching lighting tube 120 of rope light assembly 110 in a user preferred arrangement to a user preferred structure; step two 502 coupling receiver 260 to lighting tube 120 and to an alternating current source; step three 503 coupling transmitter 250 having a matching radio frequency and an integrally constructed programmable light controller 240 to the alternating current source; step four 504 programming programmable light controller 240 to a user preferred lighting theme; step five 505 displaying the user preferred lighting theme; step six 506 uncoupling lighting tube 120, receiver 260 and transmitter 250 from the alternating current source; and step seven 507 storing rope light assembly 110. [00050] It should be noted that steps 506-507 are optional steps and may not be implemented in all cases. Optional steps of method of use 500 are illustrated using dotted lines in FIG.8 so as to distinguish them from the other steps of method of use 500. [00051] In one embodiment of the present invention, a programmable code for programmable LED light system 100 may comprise the following programming code: /Pin the strip is on. #define PIN 7 //Pin the IR Sensor is on. #define IRpin 3

BENSON_J.001U_JH

//Serial Definitions

#define STARTBIT 253

#define STOPBIT 254

#define FILLSTRIPSIG 44

#define UPDATECOLORSIG 50

#define PREVIEWPIXELSIG 60

#define SETPIXELSIG 61

#define CLEARPIXELSIG 62

#define CHANGECOLSIG 30

#define SEPMODESIG 40

#define KILLSEPBIT 31

#define NUMMODES 6 //Number of modes, including off. #define NUMLENGTHS 3 //Number of preset lengths. #define MAXLEDS 300 //Specified maximum number of LEDS.

BENSON_J.001U_JH

#define MINCOLORS 1 //The minimum number of colors allowed in separation mode. i.e. the user can turn off colors until they have this many. #define MAXSPEED 20 //Maximum animation speed in milliseconds. #define MINSPEED 250 //Minimum animation speed in milliseconds. Below this speed stops moving. #define SPEEDSTEP 15 //The time by which speed in adjusted in milliseconds. //Define our globals. int led_num = 144; //Total number of LEDs, zero-ordinated. int cur_len = 1; //The current length preset. int col_tot = 11; //Total colors defined. This will almost certainly be 11, but there's nothing wrong with a little open-endedness. int col_len = 0; //The length of each color segment. This is calculated later. float col_fln = 0; //The floating-point color length. int col_seg = 0; //The length of each separation mode segment. int col_num = 0; //The number of active/enabled colors. This is calculated later. BENSON_J.001U_JH

int col_rep = 0; //The number of times to draw the colors in color separation mode 2+. int ren_stp = 0; //The number of iterations the rendering loop goes through before resetting. This is calculated later. int ren_stp_b = 256; //Rainbow steps. int ren_glx = 0; //Useful for resuming color separation mode as opposed to restarting the animation. int ren_glx_b = 0; //Useful for rainbows. int ren_bri = 255; //Global brightness multiplier. 255 is fullbright, 0 is blackout. int sep_mod = 1; //The current separation mode. int sep_prv = 1; //The previous separation mode. int sep_dly = 265; //The current animation frame delay. int absolute_offset = 0; //The number of pixels to skip when drawing. Artifact from an old devkit. int cmd_last = 0; //The last IR code recieved. int cmd_prev = 0; //The one before that.

BENSON_J.001U_JH

int mode_state = 0; //The current mode. int mode_last = 1; //The mode before we turned off. Also lets us turn on to solid mode, apparently. int ani_dir = 0; //Direction of animation progression, 0 is forward, 1 is reverse. int ani_go = 0; //Should the animation be going? int efc_col = 3; //Current color for Twinkle and Blink //Initialize our strip. There needs to be a way to clear this out, because when additional physical LED strips are added, the length can only be changed by redefining the strip. Adafruit_NeoPixel strip = Adafruit_NeoPixel(MAXLEDS+absolute_offset+1, PIN, NEO_GRB + NEO_KHZ800); //Initialize our IR sensor. Adafruit_NECremote remote(IRpin); //Colors: //0. Red //1. Green

BENSON_J.001U_JH

//2. Blue

//3. White

//4. Orange

//5. Yellow

//6. Purple

//7. Warm White

//8. Turquoise

//9. Magenta

//10. Amber

//Mask of enabled colors.

boolean color_enable[] = {0,0,0,1,0,0,0,0,0,0,0}; //The color definitions themselves.

uint32_t colors[] = {

strip.Color(255,0,0), //Red

strip.Color(0,255,0), //Green BENSON_J.001U_JH

strip.Color(0,0,255), //Blue strip.Color(255,255,255), //White strip.Color(255,100,0), //Orange strip.Color(255,255,0), //Yellow strip.Color(128,0,128), //Purple strip.Color(255,178,48), //Warm White strip.Color(175,238,238), //Turquoise strip.Color(255,0,128), //Magenta strip.Color(255,200,25) //Amber}; //Alternatively, for twinkle... int colorparts[11][3] = {

{255,0,0},

{0,255,0},

{0,0,255},

{255,255,255}, BENSON_J.001U_JH

{255,100,0},

{255,255,0},

{128,0,128},

{255,178,48},

{175,238,238},

{255,0,128},

{255,200,25} };

//Predefined, switchable strip lengths. int lengths[] = {

45,

144,

189 };

//MODE TABLE - Important stuff. void (*modes[])() = {

*ModeOffHndlr, BENSON_J.001U_JH

*ModeSepModHndlr, *ModeSolidHndlr, *ModeRainbowHndlr, *ModeBlinkHndlr, *ModeTwinkleHndlr }; // ****************************************** General Purpose Functions Go Here //Literally Nothing void dust(){} //Nothing For Your Something void dust2(int cs_s){} //Calculate the length of each color segment based on the length of the strip and the separation mode. (This is col_len.) int CalcCL(int spm){ //Preset the color length to one, in case separation mode is zero. int ccl = 1; /If separation mode is non-zero... BENSON_J.001U_JH

if(spm>0){ //The color length is calculated. if(col_num>0){ ccl = ceil(((led_num/spm)/col_num)); if(ccl<1){ccl=1;} //Calculate the floating-point color length. col_fln = (led_num/spm)/col_num; col_seg = (int) (ccl*col_num); col_rep = led_num/col_seg; }else{ccl=1;} } return ccl; } //Calculate the number of colors enabled. (This is col_num.) int CalcCN(boolean cle[]){ int cur=0; //Iterate through the color_enable mask and add one to the proto-col_num everytime we find a high bit. BENSON_J.001U_JH

for(int cc=0;cc<col_tot;cc++){

if(cle[cc]){cur++;} }

if(cur==0){cur=1;}

return cur; }

//Initialize our strips(s). This is where strip redefinition would need to happen.

void initStrips(boolean cle[],int spm){

//Update our globals.

ol_num = CalcCN(cle);

col_len = CalcCL(spm);

//Set the number of render steps.

if(spm>0){

ren_stp = col_seg;

}else{

ren_stp = led_num; }

//Initialize our strip. BENSON_J.001U_JH

strip.begin();

strip.setBrightness(ren_bri);

strip.show(); }

//Fill the strip with a color.

void FillStrip(int cr, int cg, int cb){

//Construct the selected color.

uint32_t nc=strip.Color(cr,cg,cb);

//Step through each pixel and set it to the selected color. for(int i=0;i<=led_num;i++){

strip.setPixelColor(i+absolute_offset,nc); } } //Fill the strip with a predefined color.

void FillStripC(uint32_t nc){

//Step through each pixel and set it to the selected color. for(int i=0;i<=led_num;i++){

strip.setPixelColor(i+absolute_offset,nc); } } BENSON_J.001U_JH

//Adafruit colorwheel function... no need to reinvent the wheel. uint32_t Wheel(byte WheelPos) {

WheelPos = 255 - WheelPos;

if(WheelPos < 85) {

return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);

} else if(WheelPos < 170) {

WheelPos -= 85;

return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);

} else {

WheelPos -= 170;

return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0); } } //Increment or decrement a variable to progress animation. int progressAnimation(int input){

int output;

//Serial.println("got called"); BENSON_J.001U_JH

//Serial.println(input);

if(ani_go==1){

if(ani_dir==1){

//Serial.println("minus minus");

output = input-1;

}else{

//Serial.println("plus plus");

output = input+1; }

}else{

output=input; }

//Serial.println(output);

return output; }

// ****************************************** Renderers Go Here

//The separation mode renderer!

void RenderSPM(int offset){ BENSON_J.001U_JH

//Initialize the incrementing variables. int rend_step = 1; //NOT TO BE CONFUSED WITH ren_stp. int col_step = 0; int spm_step = -1; //Make sure we have a workable number of colors if(col_num>1){ //If separation mode is 1 or higher... if(sep_mod>0){ //This while loop increments spm_step to draw multiple instances of the separation for modes 2 and up. while(spm_step<=col_rep){ col_step=0; rend_step=0; //This while loop steps through the different colors. while(col_step<col_tot){ //If the color is enabled, render it. BENSON_J.001U_JH

if(color_enable[col_step]){

//Calculate what pixel we should be drawing to.

\/ This is where we move over a lot for separation mode 2+. int pixnum=(rend_step*(col_len))+offset+(col_seg*spm_step); //Don't draw to pixels lower than the absolute offset. if(pixnum<0){

pixnum=-absolute_offset-1; }

//Draw the pixel in the correct color.

strip.setPixelColor(pixnum+absolute_offset,colors[col_step]) ; //Go to the next color length.

rend_step++; }

//Go to the next color.

col_step++; }

//Draw the next separation instance.

spm_step++; } BENSON_J.001U_JH

//Draw separation mode 0. We handle this separately as the effect achieved is actually the expected result of the separation mode approaching infinity, where as true mode zero would be a single color of infinite length. }else{ //Pretty simple stuff. It won't need changing, ever. //Calculate how many times the pattern needs repeating. int led_rpt=led_num/col_num; //Initialize a thing. int pixnum=0; int stepnum=0; //Step through the colors. while(col_step<col_tot){ //If a color is enabled, draw it. if(color_enable[col_step]){ //Repeat it however many times with the offset increased by the total colors. for(int i=0;i<led_num;i+=col_num){

BENSON_J.001U_JH

pixnum = stepnum+i+offset;

if(pixnum>=led_num){pixnum-=led_num;}

Actually draw the pixel.

strip.setPixelColor(pixnum+absolute_offset,colors[col_step]) ; } stepnum++; }

//Go to the next color.

col_step++; } }

//If there is only one color enabled, it is a solid mode.

}else if(col_num==1){

//Look until we find the enabled color.

while(col_step<col_tot){

if(color_enable[col_step]){

FillStripC(colors[col_step]); }

//Go to the next color.

col_step++; } BENSON_J.001U_JH

//If there are no colors enabled, draw black, so as to not break everything. }else{ FillStrip(0,0,0); } //Actually send all these changes to the strip. We do this SOMEWHERE ELSE for due to major opimization issues, as well as to avoid visually staggered rendering. //strip.show(); } //Predraw all the pixels so separation mode doesn't fill over initial black. void SPMPreRender(int offs){ for(int x=offs;x<col_len+offs;x++){ RenderSPM(x); } strip.show(); } //Do a rainbow. void RenderRainbow(uint16_t j) { uint16_t i; for(i=0; i<strip.numPixels(); i++) { strip.setPixelColor(i, Wheel((i+j) & 255)); } BENSON_J.001U_JH

strip.show(); }

//Twinkly.

void RenderTwinkle(int index){ int n;

for(n=0;n<(led_num/4);n++){ float r = (float) colorparts[index][0]; //float r = 255;

float g = (float) colorparts[index][1]; //float g = 0;

float b = (float) colorparts[index][2]; //float b = 0;

float di = (float) random(100);

float d = (di/125)+0.2;

r = r*d;

g = g*d; BENSON_J.001U_JH

b = b*d;

int ri = (int) r;

int gi = (int) g;

int bi = (int) b;

uint32_t color = strip.Color(ri,gi,bi);

strip.setPixelColor(random(led_num),color); }

strip.show(); }

// ****************************************** Button Handlers Go Here //Handle mode button in sepmod

void SepModModeHndlr(){

if (sep_mod == 3){sep_mod = 0;}

else {sep_mod++;}

ren_glx = 0; }

void colenable(int index){

if(col_num>MINCOLORS){ BENSON_J.001U_JH

if (color_enable[index]==1){ color_enable[index]=0;

}else{

color_enable[index]=1; }

ren_glx = 0;

}else{color_enable[index]=1;} } void BlinkTwinkleColorHndlr(int index){ efc_col=index; }

void SolidColorHndlr(int index){ FillStripC(colors[index]); }

void SolidModeHndlr(){

cur_len++;

if(cur_len==NUMLENGTHS){cur_len=0;} led_num=lengths[cur_len];

initStrips(color_enable,sep_mod); } BENSON_J.001U_JH

// ****************************************** Top-Level Handlers Go Here //Single byte command processor. This is split out so that we can take commands during ANY MODE with ease. Handlers for mode-specific events are passed in. int SingleByteCommand(int csig, void (*colHndlr)(int), void (*modHndlr)(), bool volatileColors){ int gret=0; //colHndlr is called when any color button is pressed, parameter passed is color number as per array up top. //modHndlr is called when mode button is pressed, no parameter is passed. switch(csig){ //DO COLORS //Red case 9: colHndlr(0); if(!volatileColors){gret=1;} break;

BENSON_J.001U_JH

//Green

case 8:

colHndlr(1);

if(!volatileColors){gret=1;} break;

//Blue

case 10:

colHndlr(2);

if(!volatileColors){gret=1;} break;

//White

case 11:

colHndlr(3);

if(!volatileColors){gret=1;} break; BENSON_J.001U_JH

//Orange

case 13:

colHndlr(4);

if(!volatileColors){gret=1;} break;

//Yellow

case 12:

colHndlr(5);

if(!volatileColors){gret=1;} break;

//Purple

case 14:

colHndlr(6);

if(!volatileColors){gret=1;} break; BENSON_J.001U_JH

//Warm White case 15:

colHndlr(7);

if(!volatileColors){gret=1;} break;

//Turquoise

case 20:

colHndlr(8);

if(!volatileColors){gret=1;} break;

//Magenta

case 22:

colHndlr(9);

if(!volatileColors){gret=1;} break; BENSON_J.001U_JH

//Amber

case 21:

colHndlr(10);

if(!volatileColors){gret=1;}

break;

//DO ADJUSTMENTS

//Speed Down

case 27:

sep_dly+=SPEEDSTEP;

if(sep_dly>MINSPEED){

sep_dly=MINSPEED+SPEEDSTEP; } if(sep_dly>MINSPEED){ani_go=0;} gret=1;

break;

//Speed Up BENSON_J.001U_JH

case 23:

sep_dly-=SPEEDSTEP;

if(sep_dly<MAXSPEED){ sep_dly=MAXSPEED; } if(sep_dly<=MINSPEED){ani_go=1;} gret=1;

break;

//Brightness Down

case 4:

ren_bri-=15;

if(ren_bri<15){

ren_bri=15; }

gret=1;

strip.setBrightness(ren_bri); break; BENSON_J.001U_JH

//Brightness Up

case 5:

ren_bri+=15;

if(ren_bri>255){

ren_bri=255; }

gret=1;

strip.setBrightness(ren_bri);

break;

//DO THESE MISCELLANEOUS STUFF

//Mode Button Handler

case 24:

modHndlr();

break;

//Someone held down the button, and we haven't implemented that yet. case -3: BENSON_J.001U_JH

gret=1;

break;

//Reverse the animation progression. case 19:

if(ani_dir==1){

ani_dir=0; //forward

}else{

ani_dir=1; //reverse } gret=1;

break;

//DO MODES

//Turn On

case 7:

if(mode_state!=0){gret=1;} if(mode_last==0){mode_last=1;} BENSON_J.001U_JH mode_state=mode_last; break;

//Off Mode

case 6:

if(mode_state!=0){ mode_last=mode_state; } mode_state=0; break;

//Separation Mode case 26:

mode_state=1; break;

//Solid Mode case 25:

mode_state=2; BENSON_J.001U_JH

break;

//Rainbow Mode case 17:

mode_state=3; break; //Blink Mode case 16:

mode_state=4; break; //Twinkle Mode case 18:

mode_state=5; break; default: gret=1; BENSON_J.001U_JH

break; }

return gret; }

//Accept commands and be blank.

void ModeOffHndlr(){

FillStrip(0,0,0);

strip.show();

while(1==1){

cmd_last=remote.listen(250);

int cret=SingleByteCommand(cmd_last,*dust2,*dust,false); if(cret==0){break;} } }

//Run separation mode.

void ModeSepModHndlr(){

//Re-intialize the strip with the selected parameters.

initStrips(color_enable,sep_mod);

//Initialize our breaking var. BENSON_J.001U_JH

int i=1; //If we're not resuming separation mode, predraw the colors so we don't have empty pixels visible. if(ren_glx==0){ //Render a single color-length. SPMPreRender(0); //Update our resume variable for when we actually start rendering. ren_glx=col_len; }else{ SPMPreRender(ren_glx-col_len); } //Keep going until told to stop. while(i==1){ //Run through the calculated number of rendering steps. Start where we stopped. //for(int x=ren_glx;x<ren_stp;progressAnimation(x)){ //Serial.println("start"); //Serial.println(ren_glx); BENSON_J.001U_JH

int x = ren_glx; //Render it! RenderSPM(x); strip.show(); x = progressAnimation(x); //Keep track of where we are so that we can pause and resume. ren_glx=x; //Delay the animation by the selected amount, and get an IR command. Two stones with one bird. cmd_last = remote.listen(sep_dly); //Serial.println("progresses"); //Serial.println(ren_glx); int cret = 1; if(cmd_last>0){cret=SingleByteCommand(cmd_last,*colenable ,*SepModModeH ndlr,true);}//Run the IR command. //Serial.println(cret);

BENSON_J.001U_JH

//if(cmd_last==6||cmd_last==25){i=0;FillStrip(0,0,0);stri p.show();break;} //If the command is right, break from the sepmod loop. if(cret==0){initStrips(color_enable,sep_mod);ren_glx=col_len ;SPMPreRender(0); break;}//Reset and restart sepmod for necessary changes cmd_last = 0;//Make sure we don't re-run commands. //} //If we've made a full render, go back to rendering step zero. if(ani_dir==1){ if(ren_glx==0){ ren_glx=(ren_stp); } }else{ if(ren_glx==(ren_stp)){ ren_glx=0; } } } } //Does solid colors. void ModeSolidHndlr(){ initStrips(color_enable,sep_mod); int i=1; BENSON_J.001U_JH

FillStrip(255,255,255); while(i==1){ cmd_last=remote.listen(250); int cret = SingleByteCommand

(cmd_last,*SolidColorHndlr,*SolidModeHndlr,false); strip.show(); if(cret==0){i=0;break;} cmd_prev=cmd_last; } //FillStrip(0,0,0); //strip.show(); } //Make it rainbow. void ModeRainbowHndlr(){ //Re-intialize the strip with the selected parameters. initStrips(color_enable,sep_mod); //Initialize our breaking var. int i=1; BENSON_J.001U_JH

//Keep going until told to stop. while(i==1){ int x = ren_glx_b; //Render it! RenderRainbow(x); x = progressAnimation(x); //Keep track of where we are so that we can pause and resume. ren_glx_b=x; //Delay the animation by the selected amount, and get an IR command. cmd_last = remote.listen(sep_dly); int cret = 1; if(cmd_last>0){cret=SingleByteCommand(cmd_last,*dust2,*du st,false);}//Run the IR command. if(cret==0){break;}//Reset and restart sepmod for necessary changes cmd_last = 0;//Make sure we don't re-run commands. //If we've made a full render, go back to rendering step zero. BENSON_J.001U_JH

if(ani_dir==1){

if(ren_glx==0){

ren_glx=(ren_stp_b-1); }

}else{

if(ren_glx==(ren_stp_b-1)){

ren_glx=0; } } } }

void ModeBlinkHndlr(){

//Re-intialize the strip with the selected parameters. initStrips(color_enable,sep_mod);

//Initialize our breaking var.

int it=1;

//Keep going until told to stop.

while(it==1){

for (int q=0; q < 2; q++) {

for (int i=0; i < strip.numPixels(); i=i+2) { BENSON_J.001U_JH strip.setPixelColor(i+q, colors[efc_col]); } strip.show(); //Delay the animation by the selected amount, and get an IR command. cmd_last = remote.listen(sep_dly); int cret = 1; if(cmd_last>0){cret=SingleByteCommand(cmd_last,*BlinkTwin kleColorHndlr,* dust,false);}//Run the IR command. if(cret==0){it=0;break;}//Reset and restart sepmod for necessary changes cmd_last = 0;//Make sure we don't re-run commands. for (int i=0; i < strip.numPixels(); i=i+2) { strip.setPixelColor(i+q, 0); } } } } //Twinkle like stars. void ModeTwinkleHndlr(){ //Re-initialize the strip with the selected parameters. initStrips(color_enable,sep_mod); //Initialize our breaking var. BENSON_J.001U_JH

int i=1; //Keep going until told to stop. while(1==1){ RenderTwinkle(efc_col); cmd_last = remote.listen(sep_dly); int cret = 1; if(cmd_last>0){cret=SingleByteCommand(cmd_last,*BlinkTwin kleColorHndlr,* dust,false);}//Run the IR command. if(cret==0){break;}//Reset and restart sepmod for necessary changes cmd_last = 0;//Make sure we don't re-run commands. } } //This runs first, setting up the necessary things. void setup(void) { //Do everything relevant to the LEDs. initStrips(color_enable,sep_mod); //Open our serial connection to the PC. Serial.begin(9600); } BENSON_J.001U_JH

//The main chunk of the program. void loop(void) { (*modes[mode_state])(); // } [00052] It should be noted that the steps described in the method of use can be carried out in many different orders according to user preference. The use of“step of” should not be interpreted as“step for”, in the claims herein and is not intended to invoke the provisions of 35 U.S.C. § 112, ¶ 6. Upon reading this specification, it should be appreciated that, under appropriate circumstances, considering such issues as design preference, user preferences, marketing preferences, cost, structural requirements, available materials, technological advances, etc., other methods of use arrangements such as, for example, different orders within above-mentioned list, elimination or addition of certain steps, including or excluding certain maintenance steps, etc., may be sufficient. [00053] The embodiments of the invention described herein are exemplary and numerous modifications, variations and rearrangements can be readily envisioned to achieve substantially equivalent results, all of which are intended to be embraced within the spirit and scope of the invention. Further, the purpose of the foregoing abstract is to enable the U.S. Patent and Trademark Office and the public generally, and especially the scientist, engineers and practitioners in the art who are not familiar with patent or legal terms or phraseology, to determine quickly from a cursory inspection the nature and essence of the technical disclosure of the application.

BENSON_J.001U_JH