Light Up Party Tie

1/*
2LilyPad ProtoSnap Plus Activity 3: Custom Color Mixing
3SparkFun
4  Electronics
5https://www.sparkfun.com/products/14346
6
7Expand your color
8  options using analogWrite and the RGB (Red Green Blue) LED
9
10Follow the tutorial
11  at: https://learn.sparkfun.com/tutorials/lilypad-protosnap-plus-activity-guide#3-custom-color-mixing
12
13This
14  code is released under the MIT License (http://opensource.org/licenses/MIT)
15
16******************************************************************************/
17
18//
19  The LilyPad USB Plus has a built-in RGB (Red / Green / Blue) LED.
20// In this
21  activity we'll use analogWrite to control the brightness of the three LEDs.
22//
23  Here we'll create a rainbow of tertiary colors by adding a 50%-brightness option.
24
25//
26  Create integer variables for our LED pins:
27
28// The built-in LED:
29
30int
31  RGB_red = 12;
32int RGB_green = 13;
33int RGB_blue = 14;
34int RGB_yellow = 15;
35
36//
37  The colored LEDs along the bottom edge of the board:
38
39int redLED = 6;
40int
41  greenLED = A7;
42int blueLED = A8;
43int yellowLED = A5;
44
45void setup() {
46
47//
48  Make all of our LED pins outputs:
49
50  pinMode(RGB_red, OUTPUT);
51  pinMode(RGB_green,
52  OUTPUT);
53  pinMode(RGB_blue, OUTPUT);
54  pinMode(RGB_yellow, OUTPUT);
55  pinMode(redLED,
56  OUTPUT);
57  pinMode(greenLED, OUTPUT);
58  pinMode(blueLED, OUTPUT);
59  pinMode(yellowLED,
60  OUTPUT);
61}
62
63void loop()
64{
65  // In this code we'll step through twelve
66  rainbow colors (primary, secondary, tertiary).
67
68  // Unlike digitalWrite,
69  which can be only HIGH (on) or LOW (off),
70  // analogWrite lets you smoothly
71  change the brightness from 0 (off) to 255 (fully on).
72  // When analogWrite is
73  used with the RGB LED, you can create millions of colors!
74
75  // In the analogWrite
76  functions:
77  // 0 is off
78  // 128 is halfway on (used for the tertiary colors)
79
80  // 255 is full brigthness.
81  
82  // Red
83
84  analogWrite(RGB_red,255);
85
86  analogWrite(RGB_green,0);
87  analogWrite(RGB_blue,0);
88  analogWrite(RGB_yellow,0);
89
90
91  analogWrite(redLED,255);
92  analogWrite(greenLED,0);
93  analogWrite(blueLED,0);
94
95  analogWrite(yellowLED,0);
96  delay(10);
97
98  // Orange
99
100  analogWrite(RGB_red,255);
101
102  analogWrite(RGB_green,128);
103  analogWrite(RGB_blue,0);
104  analogWrite(RGB_yellow,0);
105
106
107  analogWrite(redLED,255);
108  analogWrite(greenLED,128);
109  analogWrite(blueLED,0);
110
111  analogWrite(yellowLED,0);
112  delay(10);
113
114  // Yellow
115
116  analogWrite(RGB_red,255);
117
118  analogWrite(RGB_green,255);
119  analogWrite(RGB_blue,0);
120  analogWrite(RGB_yellow,0);
121
122
123  analogWrite(redLED,255);
124  analogWrite(greenLED,255);
125  analogWrite(blueLED,0);
126
127  analogWrite(yellowLED,0);
128  delay(10);
129
130  // Chartruese
131
132  analogWrite(RGB_red,128);
133
134  analogWrite(RGB_green,255);
135  analogWrite(RGB_blue,0);
136  analogWrite(RGB_yellow,0);
137
138
139  analogWrite(redLED,128);
140  analogWrite(greenLED,255);
141  analogWrite(blueLED,0);
142
143  analogWrite(yellowLED,0);
144  delay(10);
145
146  // Green
147
148  analogWrite(RGB_red,0);
149
150  analogWrite(RGB_green,255);
151  analogWrite(RGB_blue,0);
152  analogWrite(RGB_yellow,0);
153
154
155  analogWrite(redLED,0);
156  analogWrite(greenLED,255);
157  analogWrite(blueLED,0);
158
159  analogWrite(yellowLED,0);
160  delay(10);
161
162  // Spring Green
163
164  analogWrite(RGB_red,0);
165
166  analogWrite(RGB_green,255);
167  analogWrite(RGB_blue,128);
168  analogWrite(RGB_yellow,0);
169
170
171  analogWrite(redLED,0);
172  analogWrite(greenLED,255);
173  analogWrite(blueLED,128);
174
175  analogWrite(yellowLED,0);
176  delay(10);
177
178  // Cyan
179
180  analogWrite(RGB_red,0);
181
182  analogWrite(RGB_green,255);
183  analogWrite(RGB_blue,255);
184  analogWrite(RGB_yellow,0);
185
186
187  analogWrite(redLED,0);
188  analogWrite(greenLED,255);
189  analogWrite(blueLED,255);
190
191  analogWrite(yellowLED,0);
192  delay(10);
193
194  // Azure
195
196  analogWrite(RGB_red,0);
197
198  analogWrite(RGB_green,128);
199  analogWrite(RGB_blue,255);
200  analogWrite(RGB_yellow,0);
201
202
203  analogWrite(redLED,0);
204  analogWrite(greenLED,128);
205  analogWrite(blueLED,255);
206
207  analogWrite(yellowLED,0);
208  delay(10);
209
210  // Blue
211
212  analogWrite(RGB_red,0);
213
214  analogWrite(RGB_green,0);
215  analogWrite(RGB_blue,255);
216  analogWrite(RGB_yellow,0);
217
218
219  analogWrite(redLED,0);
220  analogWrite(greenLED,0);
221  analogWrite(blueLED,255);
222
223  analogWrite(yellowLED,0);
224  delay(10);
225
226  // Violet
227
228  analogWrite(RGB_red,128);
229
230  analogWrite(RGB_green,0);
231  analogWrite(RGB_blue,255);
232  analogWrite(RGB_yellow,128);
233
234
235  analogWrite(redLED,128);
236  analogWrite(greenLED,0);
237  analogWrite(blueLED,255);
238
239  analogWrite(yellowLED,128);
240  delay(10);
241
242  // Magenta
243  
244  analogWrite(RGB_red,255);
245
246  analogWrite(RGB_green,0);
247  analogWrite(RGB_blue,255);
248  analogWrite(RGB_yellow,255);
249
250
251  analogWrite(redLED,255);
252  analogWrite(greenLED,0);
253  analogWrite(blueLED,255);
254
255  analogWrite(yellowLED,255);
256  delay(10);
257
258  // Rose
259  
260  analogWrite(RGB_red,255);
261
262  analogWrite(RGB_green,0);
263  analogWrite(RGB_blue,128);
264  analogWrite(RGB_yellow,255);
265
266  
267  analogWrite(redLED,255);
268  analogWrite(greenLED,0);
269  analogWrite(blueLED,128);
270
271  analogWrite(yellowLED,255);
272  delay(10);
273
274  // yellow
275  
276  analogWrite(RGB_red,0);
277
278  analogWrite(RGB_green,128);
279  analogWrite(RGB_blue,0);
280  analogWrite(RGB_yellow,255);
281
282  
283  analogWrite(redLED,0);
284  analogWrite(greenLED,128);
285  analogWrite(blueLED,0);
286
287  analogWrite(yellowLED,255);
288  delay(10);
289 
290}

1/*
2LilyPad ProtoSnap Plus Activity 3: Custom Color Mixing
3SparkFun  Electronics
4https://www.sparkfun.com/products/14346
5
6Expand your color  options using analogWrite and the RGB (Red Green Blue) LED
7
8Follow the tutorial  at: https://learn.sparkfun.com/tutorials/lilypad-protosnap-plus-activity-guide#3-custom-color-mixing
9
10This  code is released under the MIT License (http://opensource.org/licenses/MIT)
11
12******************************************************************************/
13
14//  The LilyPad USB Plus has a built-in RGB (Red / Green / Blue) LED.
15// In this  activity we'll use analogWrite to control the brightness of the three LEDs.
16//  Here we'll create a rainbow of tertiary colors by adding a 50%-brightness option.
17
18//  Create integer variables for our LED pins:
19
20// The built-in LED:
21
22int  RGB_red = 12;
23int RGB_green = 13;
24int RGB_blue = 14;
25int RGB_yellow = 15;
26
27//  The colored LEDs along the bottom edge of the board:
28
29int redLED = 6;
30int  greenLED = A7;
31int blueLED = A8;
32int yellowLED = A5;
33
34void setup() {
35
36//  Make all of our LED pins outputs:
37
38  pinMode(RGB_red, OUTPUT);
39  pinMode(RGB_green,  OUTPUT);
40  pinMode(RGB_blue, OUTPUT);
41  pinMode(RGB_yellow, OUTPUT);
42  pinMode(redLED,  OUTPUT);
43  pinMode(greenLED, OUTPUT);
44  pinMode(blueLED, OUTPUT);
45  pinMode(yellowLED,  OUTPUT);
46}
47
48void loop()
49{
50  // In this code we'll step through twelve  rainbow colors (primary, secondary, tertiary).
51
52  // Unlike digitalWrite,  which can be only HIGH (on) or LOW (off),
53  // analogWrite lets you smoothly  change the brightness from 0 (off) to 255 (fully on).
54  // When analogWrite is  used with the RGB LED, you can create millions of colors!
55
56  // In the analogWrite  functions:
57  // 0 is off
58  // 128 is halfway on (used for the tertiary colors)
59  // 255 is full brigthness.
60  
61  // Red
62
63  analogWrite(RGB_red,255);
64  analogWrite(RGB_green,0);
65  analogWrite(RGB_blue,0);
66  analogWrite(RGB_yellow,0);
67
68  analogWrite(redLED,255);
69  analogWrite(greenLED,0);
70  analogWrite(blueLED,0);
71  analogWrite(yellowLED,0);
72  delay(10);
73
74  // Orange
75
76  analogWrite(RGB_red,255);
77  analogWrite(RGB_green,128);
78  analogWrite(RGB_blue,0);
79  analogWrite(RGB_yellow,0);
80
81  analogWrite(redLED,255);
82  analogWrite(greenLED,128);
83  analogWrite(blueLED,0);
84  analogWrite(yellowLED,0);
85  delay(10);
86
87  // Yellow
88
89  analogWrite(RGB_red,255);
90  analogWrite(RGB_green,255);
91  analogWrite(RGB_blue,0);
92  analogWrite(RGB_yellow,0);
93
94  analogWrite(redLED,255);
95  analogWrite(greenLED,255);
96  analogWrite(blueLED,0);
97  analogWrite(yellowLED,0);
98  delay(10);
99
100  // Chartruese
101
102  analogWrite(RGB_red,128);
103  analogWrite(RGB_green,255);
104  analogWrite(RGB_blue,0);
105  analogWrite(RGB_yellow,0);
106
107  analogWrite(redLED,128);
108  analogWrite(greenLED,255);
109  analogWrite(blueLED,0);
110  analogWrite(yellowLED,0);
111  delay(10);
112
113  // Green
114
115  analogWrite(RGB_red,0);
116  analogWrite(RGB_green,255);
117  analogWrite(RGB_blue,0);
118  analogWrite(RGB_yellow,0);
119
120  analogWrite(redLED,0);
121  analogWrite(greenLED,255);
122  analogWrite(blueLED,0);
123  analogWrite(yellowLED,0);
124  delay(10);
125
126  // Spring Green
127
128  analogWrite(RGB_red,0);
129  analogWrite(RGB_green,255);
130  analogWrite(RGB_blue,128);
131  analogWrite(RGB_yellow,0);
132
133  analogWrite(redLED,0);
134  analogWrite(greenLED,255);
135  analogWrite(blueLED,128);
136  analogWrite(yellowLED,0);
137  delay(10);
138
139  // Cyan
140
141  analogWrite(RGB_red,0);
142  analogWrite(RGB_green,255);
143  analogWrite(RGB_blue,255);
144  analogWrite(RGB_yellow,0);
145
146  analogWrite(redLED,0);
147  analogWrite(greenLED,255);
148  analogWrite(blueLED,255);
149  analogWrite(yellowLED,0);
150  delay(10);
151
152  // Azure
153
154  analogWrite(RGB_red,0);
155  analogWrite(RGB_green,128);
156  analogWrite(RGB_blue,255);
157  analogWrite(RGB_yellow,0);
158
159  analogWrite(redLED,0);
160  analogWrite(greenLED,128);
161  analogWrite(blueLED,255);
162  analogWrite(yellowLED,0);
163  delay(10);
164
165  // Blue
166
167  analogWrite(RGB_red,0);
168  analogWrite(RGB_green,0);
169  analogWrite(RGB_blue,255);
170  analogWrite(RGB_yellow,0);
171
172  analogWrite(redLED,0);
173  analogWrite(greenLED,0);
174  analogWrite(blueLED,255);
175  analogWrite(yellowLED,0);
176  delay(10);
177
178  // Violet
179
180  analogWrite(RGB_red,128);
181  analogWrite(RGB_green,0);
182  analogWrite(RGB_blue,255);
183  analogWrite(RGB_yellow,128);
184
185  analogWrite(redLED,128);
186  analogWrite(greenLED,0);
187  analogWrite(blueLED,255);
188  analogWrite(yellowLED,128);
189  delay(10);
190
191  // Magenta
192  
193  analogWrite(RGB_red,255);
194  analogWrite(RGB_green,0);
195  analogWrite(RGB_blue,255);
196  analogWrite(RGB_yellow,255);
197
198  analogWrite(redLED,255);
199  analogWrite(greenLED,0);
200  analogWrite(blueLED,255);
201  analogWrite(yellowLED,255);
202  delay(10);
203
204  // Rose
205  
206  analogWrite(RGB_red,255);
207  analogWrite(RGB_green,0);
208  analogWrite(RGB_blue,128);
209  analogWrite(RGB_yellow,255);
210  
211  analogWrite(redLED,255);
212  analogWrite(greenLED,0);
213  analogWrite(blueLED,128);
214  analogWrite(yellowLED,255);
215  delay(10);
216
217  // yellow
218  
219  analogWrite(RGB_red,0);
220  analogWrite(RGB_green,128);
221  analogWrite(RGB_blue,0);
222  analogWrite(RGB_yellow,255);
223  
224  analogWrite(redLED,0);
225  analogWrite(greenLED,128);
226  analogWrite(blueLED,0);
227  analogWrite(yellowLED,255);
228  delay(10);
229 
230}