main.cpp

00001 #include "mbed.h"
00002 #include "RNG/Random.h"
00003 #include "WakeUp/WakeUp.h"
00004 
00005 DigitalOut LED[] = {(P0_7), (P0_8), (P0_2), (P0_20), (P1_19), (P0_17), (P0_23)};// declare 7 LEDs
00006 
00007 int rndLED = 0;
00008 Random RNG = Random();
00009 
00010 void myDeepSleep() {
00011     LPC_PMU->PCON = 0x1;
00012     SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
00013     LPC_SYSCON->PDAWAKECFG &= 0xFFFFF800;
00014     __WFI();
00015 }
00016 
00017 void myPowerDown() {
00018     LPC_PMU->PCON = 0x2;
00019     SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
00020     LPC_SYSCON->PDAWAKECFG &= 0xFFFFF800;
00021     __WFI();
00022 }
00023 
00024 void sweepMode(float delayTime)
00025 {
00026         for(int x=0; x<7; x++)
00027         {
00028             LED[x] = 1;
00029             wait(delayTime);
00030         }
00031 
00032         for(int x=6; x>=0; x--)
00033         {
00034             LED[x] = 0;
00035             wait(delayTime);
00036         }
00037 }
00038 
00039 void bounceMode(float delayTime)
00040 {
00041         for(int x=0; x<7; x++)
00042         {
00043             LED[x] = 1;
00044             wait(delayTime);
00045             LED[x] = 0;
00046         }
00047 
00048         for(int x=6; x>=0; x--)
00049         {
00050             LED[x] = 1;
00051             wait(delayTime);
00052             LED[x] = 0;
00053         }
00054 }
00055 
00056 void multiSweepMode(float delayTime)
00057 {
00058         for(int w=1; w<13; w++)
00059         {            
00060             for(int x=1-w; x<13; x++)
00061             {
00062                     for(int z=0; z<w; z++) {
00063                         if(x+z>=0 && x+z < 7) {
00064                             LED[x+z]=1;
00065                         }
00066                     }
00067                     wait(delayTime);
00068                     for(int z=0; z<w; z++) {
00069                         if(x+z>=0 && x+z < 7) {
00070                             LED[x+z]=0;
00071                         }
00072                     }
00073                 
00074             }
00075         }
00076 }
00077 
00078 void pileMode(float delayTime)
00079 {
00080         for(int x=0; x<7; x++)
00081         {
00082             for(int y=0; y<(6-x); y++) {
00083                 LED[y]=1;
00084                 wait(delayTime);
00085                 LED[y]=0;
00086             }
00087             LED[6-x]=1;
00088         }
00089         wait(delayTime);
00090         for(int x=0; x<7; x++)
00091         {
00092             LED[x] = 0;
00093         }
00094 }
00095 
00096 void randomMode(float delayTime)
00097 {
00098     for(int x=0; x<128; x++) {
00099         rndLED = (int) RNG.getByte() % 8;
00100         LED[rndLED]=1;
00101         wait(0.01);
00102         LED[rndLED]=0;
00103         wait(delayTime);
00104     }
00105 }
00106 
00107 void binaryMode(float delayTime) {
00108         for(int n=0; n<128; n++) {
00109             for(int b=0; b<7; b++) {
00110                 if(n & (1 << b)) {
00111                     LED[6 - b]=1;
00112                 }
00113             }
00114             wait(delayTime);
00115             for(int b=0; b<7; b++) {
00116                 LED[b]=0;
00117             }
00118         }
00119 }
00120 
00121 void grayMode(float delayTime) {
00122         for(int b=0; b<7; b++) { LED[b]=0; }
00123         
00124         int prev=0;
00125         for(int n=1; n<128; n++) {
00126             int prevGray = (prev >> 1) ^ prev;            
00127             int gray = (n >> 1) ^ n;
00128             int diffBit = prevGray ^ gray;
00129             for(int b=0; b<7; b++) {
00130                 if(diffBit & (1 << b)) {
00131                     LED[6 - b] = (diffBit & prevGray) ? 0 : 1;
00132                     break;
00133                 }
00134             }
00135             prev = n;
00136             wait(delayTime);
00137         }
00138 }
00139 
00140 void bumpMode(float delayTime) {
00141     for(int x=0; x<3; x++) {
00142         LED[x]=1;
00143         LED[6-x]=1;
00144         wait(delayTime * 2);
00145         LED[x]=0;
00146         LED[6-x]=0;
00147     }
00148     LED[3]=1;
00149     wait(delayTime * 2);
00150     LED[3]=0;
00151     for(int x=0; x<3; x++) {
00152         LED[2-x]=1;
00153         LED[4+x]=1;
00154         wait(delayTime * 2);
00155         LED[2-x]=0;
00156         LED[4+x]=0;
00157     }
00158     wait(delayTime * 4);
00159 }
00160 
00161 int main()
00162 {
00163     while(1)
00164     {
00165         bumpMode(0.05);
00166         int x = (int) RNG.getByte() % 7;
00167         switch(x) {
00168             case 0:
00169                 binaryMode(0.025);
00170                 break;
00171             case 1:               
00172                 randomMode(0.025);
00173                 break;
00174             case 2:
00175                 grayMode(0.025);
00176                 break;                
00177             case 3:
00178                 bounceMode(0.05);
00179                 break;
00180             case 4:
00181                 pileMode(0.05);
00182                 break;
00183             case 5:
00184                 multiSweepMode(0.025);
00185                 break;
00186             case 6:
00187                 sweepMode(0.05);
00188                 break;
00189         }
00190         bumpMode(0.05);
00191         WakeUp::set(30);
00192         myPowerDown();
00193     }
00194 }