RgbControl.cpp

00001 #include "mbed.h"
00002 #include "QEI.h"
00003 #include "PololuLedStrip.h"
00004 
00005 
00006 PololuLedStrip      led7(PB_0);
00007 PololuLedStrip      led6(PA_12);
00008 PololuLedStrip      led5(PB_6);
00009 PololuLedStrip      led4(PB_1);
00010 PololuLedStrip      led3(PA_8);
00011 PololuLedStrip      led2(PA_11);
00012 PololuLedStrip      led1(PA_3);
00013 PololuLedStrip      led0(PA_4);
00014 
00015 #define LED_COUNT 16
00016 
00017 rgb_color colors0[LED_COUNT];
00018 rgb_color colors1[LED_COUNT];
00019 rgb_color colors2[LED_COUNT];
00020 rgb_color colors3[LED_COUNT];
00021 rgb_color colors4[LED_COUNT];
00022 rgb_color colors5[LED_COUNT];
00023 rgb_color colors6[LED_COUNT];
00024 rgb_color colors7[LED_COUNT];
00025 
00026 Ticker      led;
00027 
00028 extern              QEI re;
00029 extern int R;
00030 extern int G;
00031 extern int B;
00032 extern              Serial bt;
00033 extern int dayLed;
00034 
00035 void LedOn1()
00036 {
00037         
00038         int pulse = re.getPulses();  
00039         int d = pulse/200;
00040         
00041         if(48>=d)
00042         {
00043             
00044             uint8_t r[8];
00045             uint8_t g[8];
00046             uint8_t b[8];   
00047             
00048             for (int i=0 ; i<8 ; i++)
00049             {
00050                 int n = (i+1); 
00051                 int moveL_r = ((R/6)*(d-1*n*6))+R;
00052                 int moveL_g = ((G/6)*(d-1*n*6))+G;
00053                 int moveL_b = ((B/6)*(d-1*n*6))+B;
00054                 
00055                 moveL_r = (0 >= moveL_r) ? 0: moveL_r;
00056                 moveL_g = (0 >= moveL_g) ? 0: moveL_g;
00057                 moveL_b = (0 >= moveL_b) ? 0: moveL_b;
00058                 
00059                 moveL_r = (R <= moveL_r) ? R: moveL_r;
00060                 moveL_g = (G <= moveL_g) ? G: moveL_g;
00061                 moveL_b = (B <= moveL_b) ? B: moveL_b;
00062                 
00063                 
00064                 r[i] = moveL_r;
00065                 g[i] = moveL_g;
00066                 b[i] = moveL_b;
00067                 
00068             } 
00069             
00070             
00071         
00072             for(int i=0; i<16; i++)
00073             {
00074                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00075                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00076                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00077                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00078                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00079                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00080                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00081                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00082             }
00083             
00084             
00085             led0.write(colors0, LED_COUNT);
00086             led1.write(colors1, LED_COUNT);
00087             led2.write(colors2, LED_COUNT);
00088             led3.write(colors3, LED_COUNT);
00089             led4.write(colors4, LED_COUNT);
00090             led5.write(colors5, LED_COUNT);
00091             led6.write(colors6, LED_COUNT);
00092             led7.write(colors7, LED_COUNT);
00093             
00094         }
00095         
00096         else if(52<=d)
00097         {
00098             uint8_t r[8];
00099             uint8_t g[8];
00100             uint8_t b[8];
00101                                     
00102             for (int i=0 ; i<8 ; i++)
00103             {
00104                 int moveR_r = -1*(R/6)*(d-1*(52+(i+1)*6))+R;
00105                 int moveR_g = -1*(G/6)*(d-1*(52+(i+1)*6))+G;
00106                 int moveR_b = -1*(B/6)*(d-1*(52+(i+1)*6))+B;
00107                                 
00108                 
00109                 moveR_r = (0 >= moveR_r) ? 0: moveR_r;
00110                 moveR_g = (0 >= moveR_g) ? 0: moveR_g;
00111                 moveR_b = (0 >= moveR_b) ? 0: moveR_b;
00112                 
00113                 moveR_r = (R <= moveR_r) ? R: moveR_r;
00114                 moveR_g = (G <= moveR_g) ? G: moveR_g;
00115                 moveR_b = (B <= moveR_b) ? B: moveR_b;
00116                 
00117                 
00118                 r[i] = moveR_r;
00119                 g[i] = moveR_g;
00120                 b[i] = moveR_b;
00121             }
00122 
00123             
00124         
00125             for(int i=0; i<16; i++)
00126             {
00127                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00128                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00129                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00130                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00131                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00132                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00133                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00134                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00135             }
00136             
00137             
00138             led0.write(colors0, LED_COUNT);
00139             led1.write(colors1, LED_COUNT);
00140             led2.write(colors2, LED_COUNT);
00141             led3.write(colors3, LED_COUNT);
00142             led4.write(colors4, LED_COUNT);
00143             led5.write(colors5, LED_COUNT);
00144             led6.write(colors6, LED_COUNT);
00145             led7.write(colors7, LED_COUNT);
00146             
00147         }
00148         
00149         else
00150         {
00151             
00152             for(int i=0; i<16; i++)
00153             {
00154                 colors0[i] = (rgb_color){ R, G, B };
00155                 colors1[i] = (rgb_color){ R, G, B };
00156                 colors2[i] = (rgb_color){ R, G, B };
00157                 colors3[i] = (rgb_color){ R, G, B };
00158                 colors4[i] = (rgb_color){ R, G, B };
00159                 colors5[i] = (rgb_color){ R, G, B };
00160                 colors6[i] = (rgb_color){ R, G, B };
00161                 colors7[i] = (rgb_color){ R, G, B };
00162             }
00163             
00164             
00165             led0.write(colors0, LED_COUNT);
00166             led1.write(colors1, LED_COUNT);
00167             led2.write(colors2, LED_COUNT);
00168             led3.write(colors3, LED_COUNT);
00169             led4.write(colors4, LED_COUNT);
00170             led5.write(colors5, LED_COUNT);
00171             led6.write(colors6, LED_COUNT);
00172             led7.write(colors7, LED_COUNT);
00173         }
00174     
00175 }
00176 
00177 
00178 void LedOn2()
00179 {
00180     
00181         int pulse = re.getPulses();  
00182         int p = pulse/200;
00183         uint8_t k[8];
00184         int n = 8;
00185         int d = 6;
00186         double bi= 0.02f;
00187         
00188         uint8_t r[8];
00189         uint8_t g[8];
00190         uint8_t b[8];
00191         
00192         for (int i=0 ; i<8 ; i++)
00193         {
00194             k[i] = ((n-i)*d)/log((1/bi)+1);
00195         }
00196         
00197         
00198         if(48>=p)
00199         {
00200 
00201 
00202             for (int i=0 ; i<8 ; i++)
00203             {
00204 
00205                 int moveL_r = R*bi*(10^((p-1*i*d)/k[i])-1);
00206                 int moveL_g = G*bi*(10^((p-1*i*d)/k[i])-1);
00207                 int moveL_b = B*bi*(10^((p-1*i*d)/k[i])-1);;
00208                  
00209                 moveL_r = (0 >= moveL_r) ? 0: moveL_r;
00210                 moveL_g = (0 >= moveL_g) ? 0: moveL_g;
00211                 moveL_b = (0 >= moveL_b) ? 0: moveL_b;
00212                 
00213                 moveL_r = (R <= moveL_r) ? R: moveL_r;
00214                 moveL_g = (G <= moveL_g) ? G: moveL_g;
00215                 moveL_b = (B <= moveL_b) ? B: moveL_b;
00216                  
00217                 r[i] = moveL_r;
00218                 g[i] = moveL_g;
00219                 b[i] = moveL_b;
00220     
00221             } 
00222             
00223         
00224             for(int i=0; i<16; i++)
00225             {
00226                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00227                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00228                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00229                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00230                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00231                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00232                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00233                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00234             }
00235             
00236             
00237             led0.write(colors0, LED_COUNT);
00238             led1.write(colors1, LED_COUNT);
00239             led2.write(colors2, LED_COUNT);
00240             led3.write(colors3, LED_COUNT);
00241             led4.write(colors4, LED_COUNT);
00242             led5.write(colors5, LED_COUNT);
00243             led6.write(colors6, LED_COUNT);
00244             led7.write(colors7, LED_COUNT);
00245             
00246  
00247           
00248         }
00249         
00250         else if(49<=p)
00251         {
00252 
00253                                     
00254             for (int i=0 ; i<8 ; i++)
00255             {
00256 
00257                 int moveR_r = R*bi*(10^((-1*p+(n+1+i)*d)/k[n-1-i])-1);
00258                 int moveR_g = G*bi*(10^((-1*p+(n+1+i)*d)/k[n-1-i])-1);
00259                 int moveR_b = B*bi*(10^((-1*p+(n+1+i)*d)/k[n-1-i])-1);
00260                 
00261                 moveR_r = (0 >= moveR_r) ? 0: moveR_r;
00262                 moveR_g = (0 >= moveR_g) ? 0: moveR_g;
00263                 moveR_b = (0 >= moveR_b) ? 0: moveR_b;
00264                 
00265                 moveR_r = (R <= moveR_r) ? R: moveR_r;
00266                 moveR_g = (G <= moveR_g) ? G: moveR_g;
00267                 moveR_b = (B <= moveR_b) ? B: moveR_b;
00268                 
00269                 r[i] = moveR_r;
00270                 g[i] = moveR_g;
00271                 b[i] = moveR_b;
00272                                 
00273             }
00274 
00275             
00276         
00277             for(int i=0; i<16; i++)
00278             {
00279                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00280                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00281                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00282                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00283                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00284                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00285                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00286                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00287             }
00288             
00289             
00290             led0.write(colors0, LED_COUNT);
00291             led1.write(colors1, LED_COUNT);
00292             led2.write(colors2, LED_COUNT);
00293             led3.write(colors3, LED_COUNT);
00294             led4.write(colors4, LED_COUNT);
00295             led5.write(colors5, LED_COUNT);
00296             led6.write(colors6, LED_COUNT);
00297             led7.write(colors7, LED_COUNT);
00298             
00299         }
00300         
00301 //        else
00302 //        {
00303 //            
00304 //            for(int i=0; i<16; i++)
00305 //            {
00306 //                colors0[i] = (rgb_color){ R, G, B };
00307 //                colors1[i] = (rgb_color){ R, G, B };
00308 //                colors2[i] = (rgb_color){ R, G, B };
00309 //                colors3[i] = (rgb_color){ R, G, B };
00310 //                colors4[i] = (rgb_color){ R, G, B };
00311 //                colors5[i] = (rgb_color){ R, G, B };
00312 //                colors6[i] = (rgb_color){ R, G, B };
00313 //                colors7[i] = (rgb_color){ R, G, B };
00314 //            }
00315 //            
00316 //            
00317 //            led0.write(colors0, LED_COUNT);
00318 //            led1.write(colors1, LED_COUNT);
00319 //            led2.write(colors2, LED_COUNT);
00320 //            led3.write(colors3, LED_COUNT);
00321 //            led4.write(colors4, LED_COUNT);
00322 //            led5.write(colors5, LED_COUNT);
00323 //            led6.write(colors6, LED_COUNT);
00324 //            led7.write(colors7, LED_COUNT);
00325 //        }
00326 
00327 }
00328 
00329 void LedOn3()
00330 {
00331     
00332         int pulse = re.getPulses();  
00333         int d = pulse/200;
00334         
00335         
00336         if(48>=d)
00337         {
00338             
00339             uint8_t r[8];
00340             uint8_t g[8];
00341             uint8_t b[8];   
00342 
00343             
00344             for (int i=0 ; i<8 ; i++)
00345             { 
00346                 int moveL_r = ((R/(48-6*(i)))+1)*(d-48)+R;
00347                 int moveL_g = ((G/(48-6*(i)))+1)*(d-48)+G;
00348                 int moveL_b = ((B/(48-6*(i)))+1)*(d-48)+B;
00349                 
00350                 r[i] = (0 >= moveL_r) ? 0: moveL_r;
00351                 g[i] = (0 >= moveL_g) ? 0: moveL_g;
00352                 b[i] = (0 >= moveL_b) ? 0: moveL_b;
00353             } 
00354             
00355             
00356         
00357             for(int i=0; i<16; i++)
00358             {
00359                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00360                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00361                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00362                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00363                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00364                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00365                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00366                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00367             }
00368             
00369             
00370             led0.write(colors0, LED_COUNT);
00371             led1.write(colors1, LED_COUNT);
00372             led2.write(colors2, LED_COUNT);
00373             led3.write(colors3, LED_COUNT);
00374             led4.write(colors4, LED_COUNT);
00375             led5.write(colors5, LED_COUNT);
00376             led6.write(colors6, LED_COUNT);
00377             led7.write(colors7, LED_COUNT);
00378             
00379         }
00380         
00381         else if(52<=d)
00382         {
00383             uint8_t r[8];
00384             uint8_t g[8];
00385             uint8_t b[8];
00386                                     
00387             for (int i=0 ; i<8 ; i++)
00388             {
00389                 int moveR_r = ((-1*R/(6+6*(i)))-1)*(d-52)+R;
00390                 int moveR_g = ((-1*G/(6+6*(i)))-1)*(d-52)+G;
00391                 int moveR_b = ((-1*B/(6+6*(i)))-1)*(d-52)+B;
00392                                 
00393                 r[i] = (0 >= moveR_r) ? 0:moveR_r ;
00394                 g[i] = (0 >= moveR_g) ? 0:moveR_g ;
00395                 b[i] = (0 >= moveR_b) ? 0:moveR_b ;
00396             }
00397 
00398             
00399         
00400             for(int i=0; i<16; i++)
00401             {
00402                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00403                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00404                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00405                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00406                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00407                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00408                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00409                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00410             }
00411             
00412             
00413             led0.write(colors0, LED_COUNT);
00414             led1.write(colors1, LED_COUNT);
00415             led2.write(colors2, LED_COUNT);
00416             led3.write(colors3, LED_COUNT);
00417             led4.write(colors4, LED_COUNT);
00418             led5.write(colors5, LED_COUNT);
00419             led6.write(colors6, LED_COUNT);
00420             led7.write(colors7, LED_COUNT);
00421             
00422         }
00423         
00424         else
00425         {
00426             
00427             for(int i=0; i<16; i++)
00428             {
00429                 colors0[i] = (rgb_color){ R, G, B };
00430                 colors1[i] = (rgb_color){ R, G, B };
00431                 colors2[i] = (rgb_color){ R, G, B };
00432                 colors3[i] = (rgb_color){ R, G, B };
00433                 colors4[i] = (rgb_color){ R, G, B };
00434                 colors5[i] = (rgb_color){ R, G, B };
00435                 colors6[i] = (rgb_color){ R, G, B };
00436                 colors7[i] = (rgb_color){ R, G, B };
00437             }
00438             
00439             
00440             led0.write(colors0, LED_COUNT);
00441             led1.write(colors1, LED_COUNT);
00442             led2.write(colors2, LED_COUNT);
00443             led3.write(colors3, LED_COUNT);
00444             led4.write(colors4, LED_COUNT);
00445             led5.write(colors5, LED_COUNT);
00446             led6.write(colors6, LED_COUNT);
00447             led7.write(colors7, LED_COUNT);
00448         }
00449     
00450 }
00451 
00452 void MoonPhase()
00453 {
00454          
00455         int d = dayLed;;
00456         
00457         if(48>=d)
00458         {
00459             
00460             uint8_t r[8];
00461             uint8_t g[8];
00462             uint8_t b[8];   
00463             
00464             for (int i=0 ; i<8 ; i++)
00465             {
00466                 int n = (i+1); 
00467                 int moveL_r = ((R/6)*(d-1*n*6))+R;
00468                 int moveL_g = ((G/6)*(d-1*n*6))+G;
00469                 int moveL_b = ((B/6)*(d-1*n*6))+B;
00470                 
00471                 moveL_r = (0 >= moveL_r) ? 0: moveL_r;
00472                 moveL_g = (0 >= moveL_g) ? 0: moveL_g;
00473                 moveL_b = (0 >= moveL_b) ? 0: moveL_b;
00474                 
00475                 moveL_r = (R <= moveL_r) ? R: moveL_r;
00476                 moveL_g = (G <= moveL_g) ? G: moveL_g;
00477                 moveL_b = (B <= moveL_b) ? B: moveL_b;
00478                 
00479                 
00480                 r[i] = moveL_r;
00481                 g[i] = moveL_g;
00482                 b[i] = moveL_b;
00483                 
00484             } 
00485             
00486             
00487         
00488             for(int i=0; i<16; i++)
00489             {
00490                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00491                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00492                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00493                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00494                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00495                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00496                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00497                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00498             }
00499             
00500             
00501             led0.write(colors0, LED_COUNT);
00502             led1.write(colors1, LED_COUNT);
00503             led2.write(colors2, LED_COUNT);
00504             led3.write(colors3, LED_COUNT);
00505             led4.write(colors4, LED_COUNT);
00506             led5.write(colors5, LED_COUNT);
00507             led6.write(colors6, LED_COUNT);
00508             led7.write(colors7, LED_COUNT);
00509             
00510         }
00511         
00512         else if(52<=d)
00513         {
00514             uint8_t r[8];
00515             uint8_t g[8];
00516             uint8_t b[8];
00517                                     
00518             for (int i=0 ; i<8 ; i++)
00519             {
00520                 int moveR_r = -1*(R/6)*(d-1*(52+(i+1)*6))+R;
00521                 int moveR_g = -1*(G/6)*(d-1*(52+(i+1)*6))+G;
00522                 int moveR_b = -1*(B/6)*(d-1*(52+(i+1)*6))+B;
00523                                 
00524                 
00525                 moveR_r = (0 >= moveR_r) ? 0: moveR_r;
00526                 moveR_g = (0 >= moveR_g) ? 0: moveR_g;
00527                 moveR_b = (0 >= moveR_b) ? 0: moveR_b;
00528                 
00529                 moveR_r = (R <= moveR_r) ? R: moveR_r;
00530                 moveR_g = (G <= moveR_g) ? G: moveR_g;
00531                 moveR_b = (B <= moveR_b) ? B: moveR_b;
00532                 
00533                 
00534                 r[i] = moveR_r;
00535                 g[i] = moveR_g;
00536                 b[i] = moveR_b;
00537             }
00538 
00539             
00540         
00541             for(int i=0; i<16; i++)
00542             {
00543                 colors0[i] = (rgb_color){ r[0], g[0], b[0] };
00544                 colors1[i] = (rgb_color){ r[1], g[1], b[1] };
00545                 colors2[i] = (rgb_color){ r[2], g[2], b[2] };
00546                 colors3[i] = (rgb_color){ r[3], g[3], b[3] };
00547                 colors4[i] = (rgb_color){ r[4], g[4], b[4] };
00548                 colors5[i] = (rgb_color){ r[5], g[5], b[5] };
00549                 colors6[i] = (rgb_color){ r[6], g[6], b[6] };
00550                 colors7[i] = (rgb_color){ r[7], g[7], b[7] };
00551             }
00552             
00553             
00554             led0.write(colors0, LED_COUNT);
00555             led1.write(colors1, LED_COUNT);
00556             led2.write(colors2, LED_COUNT);
00557             led3.write(colors3, LED_COUNT);
00558             led4.write(colors4, LED_COUNT);
00559             led5.write(colors5, LED_COUNT);
00560             led6.write(colors6, LED_COUNT);
00561             led7.write(colors7, LED_COUNT);
00562             
00563         }
00564         
00565         else
00566         {
00567             
00568             for(int i=0; i<16; i++)
00569             {
00570                 colors0[i] = (rgb_color){ R, G, B };
00571                 colors1[i] = (rgb_color){ R, G, B };
00572                 colors2[i] = (rgb_color){ R, G, B };
00573                 colors3[i] = (rgb_color){ R, G, B };
00574                 colors4[i] = (rgb_color){ R, G, B };
00575                 colors5[i] = (rgb_color){ R, G, B };
00576                 colors6[i] = (rgb_color){ R, G, B };
00577                 colors7[i] = (rgb_color){ R, G, B };
00578             }
00579             
00580             
00581             led0.write(colors0, LED_COUNT);
00582             led1.write(colors1, LED_COUNT);
00583             led2.write(colors2, LED_COUNT);
00584             led3.write(colors3, LED_COUNT);
00585             led4.write(colors4, LED_COUNT);
00586             led5.write(colors5, LED_COUNT);
00587             led6.write(colors6, LED_COUNT);
00588             led7.write(colors7, LED_COUNT);
00589         }
00590     
00591 }
00592 
00593 
00594 void ModeSelect(int mode)
00595 {
00596     
00597     switch(mode)
00598     {
00599         
00600         case 0 :
00601         
00602         led.detach();
00603 
00604         
00605         break;
00606         
00607         case 1 :
00608         led.detach();
00609         
00610         R = 119;
00611         G = 66;
00612         B = 255;
00613         
00614         led.attach(&LedOn1, 0.05);
00615         
00616         break;
00617         
00618         case 2 :
00619 
00620         led.detach();
00621         
00622         R = 119;
00623         G = 66;
00624         B = 255;
00625         
00626         led.attach(&LedOn2, 0.05);
00627         break;
00628         
00629         case 3 :
00630     
00631         led.detach();
00632         
00633         R = 119;
00634         G = 66;
00635         B = 255;
00636         
00637         led.attach(&LedOn3, 0.05);
00638         
00639         break;
00640         
00641         case 4 :
00642     
00643         led.detach();
00644         
00645         R = 119;
00646         G = 66;
00647         B = 255;
00648         
00649         led.attach(&MoonPhase, 0.05);
00650         
00651         break;
00652         
00653     }
00654     
00655 }
00656