LEDFunctions.cpp

00001 /*****************************************************************************
00002 ** @brief controlling                                                       **  
00003 ** @detail                                                                  **
00004 ** @argument: ipwd: pwd class                                               **
00005 *****************************************************************************/  
00006 
00007 #include "mbed.h"
00008 #include "LEDFunctions.h"
00009 #include "UniPWM.h" 
00010 //#include "rtos.h"
00011 
00012 //Serial pc(USBTX,USBRX);
00013  
00014 LEDFunctions::LEDFunctions() 
00015 {
00016     m_pwm.push_back(new UniPWM(p5));
00017     m_pwm[0]->duty(0);
00018     m_map.insert(std::pair<std::string, int>("p5", 0));
00019     m_pwm.push_back(new UniPWM(p6));
00020     m_pwm[1]->duty(0);
00021     m_map.insert(std::pair<std::string, int>("p6", 1));
00022     m_pwm.push_back(new UniPWM(p7));
00023     m_pwm[2]->duty(0);
00024     m_map.insert(std::pair<std::string, int>("p7", 2));
00025     m_pwm.push_back(new UniPWM(p8));
00026     m_pwm[3]->duty(0);
00027     m_map.insert(std::pair<std::string, int>("p8", 3));
00028     m_pwm.push_back(new UniPWM(p9));
00029     m_pwm[4]->duty(0);
00030     m_map.insert(std::pair<std::string, int>("p9", 4));
00031     m_pwm.push_back(new UniPWM(p10));
00032     m_pwm[5]->duty(0);
00033     m_map.insert(std::pair<std::string, int>("p10", 5));
00034     m_pwm.push_back(new UniPWM(p11));
00035     m_pwm[6]->duty(0);
00036     m_map.insert(std::pair<std::string, int>("p11", 6));
00037     m_pwm.push_back(new UniPWM(p12));
00038     m_pwm[7]->duty(0);
00039     m_map.insert(std::pair<std::string, int>("p12", 7));
00040     m_pwm.push_back(new UniPWM(p13));
00041     m_pwm[8]->duty(0);
00042     m_map.insert(std::pair<std::string, int>("p13", 8));
00043     m_pwm.push_back(new UniPWM(p14));
00044     m_pwm[9]->duty(0);
00045     m_map.insert(std::pair<std::string, int>("p14", 9));
00046     m_pwm.push_back(new UniPWM(p15)); // UniPWM(p15)
00047     m_pwm[10]->duty(0);
00048     m_map.insert(std::pair<std::string, int>("p15", 10));
00049     m_pwm.push_back(new UniPWM(p16));
00050     m_pwm[11]->duty(0);
00051     m_map.insert(std::pair<std::string, int>("p16", 11));
00052     m_pwm.push_back(new UniPWM(p17));
00053     m_pwm[12]->duty(0);
00054     m_map.insert(std::pair<std::string, int>("p17", 12));
00055     m_pwm.push_back(new UniPWM(p18));
00056     m_pwm[13]->duty(0);
00057     m_map.insert(std::pair<std::string, int>("p18", 13));
00058     m_pwm.push_back(new UniPWM(p19));
00059     m_pwm[14]->duty(0);
00060     m_map.insert(std::pair<std::string, int>("p19", 14));
00061     m_pwm.push_back(new UniPWM(p20));
00062     m_pwm[15]->duty(0);
00063     m_map.insert(std::pair<std::string, int>("p20", 15));
00064     m_pwm.push_back(new UniPWM(p21));
00065     m_pwm[16]->duty(0);
00066     m_map.insert(std::pair<std::string, int>("p21", 16));
00067     m_pwm.push_back(new UniPWM(p22));
00068     m_pwm[17]->duty(0);
00069     m_map.insert(std::pair<std::string, int>("p22", 17));
00070     m_pwm.push_back(new UniPWM(p23));
00071     m_pwm[18]->duty(0);
00072     m_map.insert(std::pair<std::string, int>("p23", 18));
00073     m_pwm.push_back(new UniPWM(p24));
00074     m_pwm[19]->duty(0);
00075     m_map.insert(std::pair<std::string, int>("p24", 19));
00076     m_pwm.push_back(new UniPWM(p25));
00077     m_pwm[20]->duty(0);
00078     m_map.insert(std::pair<std::string, int>("p25", 20));
00079     m_pwm.push_back(new UniPWM(p26));
00080     m_pwm[21]->duty(0);
00081     m_map.insert(std::pair<std::string, int>("p26", 21));
00082     m_pwm.push_back(new UniPWM(p27));
00083     m_pwm[22]->duty(0);
00084     m_map.insert(std::pair<std::string, int>("p27", 22));
00085     m_pwm.push_back(new UniPWM(p28));
00086     m_pwm[23]->duty(0);
00087     m_map.insert(std::pair<std::string, int>("p28", 23));
00088     m_pwm.push_back(new UniPWM(p29));
00089     m_pwm[24]->duty(0);
00090     m_map.insert(std::pair<std::string, int>("p29", 24));
00091     m_pwm.push_back(new UniPWM(p30));
00092     m_pwm[25]->duty(0);
00093     m_map.insert(std::pair<std::string, int>("p30", 25));
00094     m_pwm.push_back(new UniPWM(LED1));
00095     m_pwm[26]->duty(0);
00096     m_map.insert(std::pair<std::string, int>("LED1", 26));
00097     m_pwm.push_back(new UniPWM(LED2));
00098     m_pwm[27]->duty(0);
00099     m_map.insert(std::pair<std::string, int>("LED2", 27));
00100     m_pwm.push_back(new UniPWM(LED3));
00101     m_pwm[28]->duty(0);
00102     m_map.insert(std::pair<std::string, int>("LED3", 28));
00103     m_pwm.push_back(new UniPWM(LED4));
00104     m_pwm[29]->duty(0);
00105     m_map.insert(std::pair<std::string, int>("LED4", 29));
00106 }
00107 
00108 void LEDFunctions::on(int n, int d, float b, float s){
00109     if(s > 1){
00110         for(float k = b/s; k < b; k += b/s){
00111             p += b/s;
00112             m_pwm[n]->duty(p);
00113             //Thread::wait(100);
00114             wait(0.1);
00115         }
00116         for(float i = s*0.1; i < d; i += 0.1){
00117             m_pwm[n]->duty(b);
00118             //Thread::wait(100);
00119             wait(0.1);
00120         }
00121     }
00122     else{ 
00123         for(float i = 0; i < d; i += 1){
00124             m_pwm[n]->duty(b);
00125             //Thread::wait(1000);
00126             wait(1);
00127         }
00128     }
00129     m_pwm[n]->duty(0);
00130 }
00131 
00132 /*
00133 void LEDFunctions::on_abst(int n, int starttime, int endtime, float b, float s){
00134     id(n);
00135     if(time==starttime){
00136         if(s > 1){
00137             for(k = 0; k = b; k = b/s){
00138                 p = p + b/s;
00139                 _pin.duty(p);
00140                 wait(0.1);
00141             }
00142             for(i = starttime + b; i < endtime; i += 0.1){
00143                 _pin.duty(b);
00144                 wait(0.1);    
00145             }
00146         }
00147         else{ 
00148             for(i = starttime; i = endtime; i += 0.1){
00149                 _pin.duty(b);
00150                 wait(0.1);
00151             }
00152         }
00153     }
00154 }
00155 */
00156 void LEDFunctions::on_forever(int n, float b, float s){
00157     if(s > 1){
00158         for(float k = b/s; k < b; k += b/s){
00159             p += b/s;
00160             m_pwm[n]->duty(p);
00161             //Thread::wait(100);
00162             wait(0.1);
00163         }
00164     }
00165     else{ 
00166         m_pwm[n]->duty(b);
00167     }
00168 }
00169 
00170 void LEDFunctions::off_forever(int n, float b, float s){
00171     if(s > 1){
00172         for(float k = 1; k > b; k -= 1/s){
00173             p = k;
00174             m_pwm[n]->duty(p);
00175             //Thread::wait(100);
00176             wait(0.1);
00177         }
00178         m_pwm[n]->duty(b);
00179     }
00180     else{ 
00181         m_pwm[n]->duty(b);
00182     }
00183 }
00184 
00185 void LEDFunctions::blink(int n, int f, int d, float lb, float ub, float s){
00186     float time = 1.0 / (2.0*f);
00187     float inc = 1.0/f;
00188     for(float i = 0.0; i < d; i += inc){
00189         if(s > 1){
00190             for(float k = lb; k < ub; k += (ub-lb)/s){
00191                     p += (ub-lb)/s;
00192                     m_pwm[n]->duty(p);
00193                     //Thread::wait(time*1000/s)
00194                     wait(time/s);       
00195             }
00196             for(float k = ub; k > lb; k -= (ub-lb)/s){
00197                     p = k;
00198                     m_pwm[n]->duty(k);
00199                     //Thread::wait(time*1000/s);
00200                     wait(time/s);
00201             }
00202             m_pwm[n]->duty(lb);
00203             //Thread::wait(time*1000/s);
00204             wait(time/s);
00205         }
00206         else {
00207             m_pwm[n]->duty(ub);
00208             //Thread::wait(time*1000);
00209             wait(1);
00210             m_pwm[n]->duty(lb);
00211             //Thread::wait(time*1000);
00212             wait(1);
00213         }
00214     }
00215 }
00216 /*
00217 void LEDFunctions::blink_abst(int n, int f, int startime, int endtime, float ub, float lb, float s){
00218     id(n);
00219     for(i = starttime; i = endtime; i += 1/frequency){
00220         if(s > 1){
00221             for(k = lb; k = ub; k += (ub-lb)/s){
00222                     lb = lb + (up-lb)/s;
00223                     _pin.duty(lb);
00224                     wait((1/2*f)/((ub-lb)/s));
00225             }
00226             for(k = ub; k = lb; k -= ub/s){
00227                     ub = ub - (ub-lb)/s;
00228                     _pin.duty(ub);
00229                     wait((1/2*f)/((ub-lb)/s));
00230             }
00231         }
00232         else{
00233             _pin.duty(ub);
00234             wait(1/2*f);
00235             _pin.duty(lb);
00236             wait(1/2*f);
00237         }
00238     }
00239 }
00240 */