Tickers.h

00001 /*
00002     Copyright (c) 2011 Andy Kirkham
00003  
00004     Permission is hereby granted, free of charge, to any person obtaining a copy
00005     of this software and associated documentation files (the "Software"), to deal
00006     in the Software without restriction, including without limitation the rights
00007     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00008     copies of the Software, and to permit persons to whom the Software is
00009     furnished to do so, subject to the following conditions:
00010  
00011     The above copyright notice and this permission notice shall be included in
00012     all copies or substantial portions of the Software.
00013  
00014     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00015     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00016     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00017     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00018     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00019     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00020     THE SOFTWARE.
00021 */
00022 
00023 #ifndef AJK_TICKERS_H
00024 #define AJK_TICKERS_H
00025 
00026 #include "mbed.h"
00027 #include "TickersSys.h"
00028 #include <list>
00029 
00030 namespace AjK {
00031 
00032 // Mimic Mbed's Ticker class but using TIMER1 
00033 // (note, only goes to milliseconds level not microseconds!)
00034 
00035 class Ticker0Sys;
00036 extern Ticker0Sys _ticker0Sys;
00037 
00038 class Ticker0 {
00039 protected:
00040     FunctionPointer callback;
00041     uint32_t counter;
00042     uint32_t reload;
00043 public:
00044     Ticker0();
00045     ~Ticker0();
00046     void tick(void);
00047     
00048     void detach(void) {        
00049         callback.attach();
00050     }
00051     void attach(void (*fptr)(void), double d) {
00052         counter = reload = (uint32_t)( d * 1000.0 );
00053         callback.attach(fptr);
00054     }
00055     template<typename T>
00056     void attach(T* tptr, void (T::*mptr)(void), double d) {  
00057         if((mptr != NULL) && (tptr != NULL)) {
00058             counter = reload = (uint32_t)( d * 1000.0 );
00059             callback.attach(tptr, mptr);         
00060         }        
00061     }
00062 };
00063 
00064 // Mimic Mbed's Ticker class but using TIMER1 
00065 // (note, only goes to milliseconds level not microseconds!)
00066 
00067 class Ticker1Sys;
00068 extern Ticker1Sys _ticker1Sys;
00069 
00070 class Ticker1 {
00071 protected:
00072     FunctionPointer callback;
00073     uint32_t counter;
00074     uint32_t reload;
00075 public:
00076     Ticker1();
00077     ~Ticker1();
00078     void tick(void);
00079     
00080     void detach(void) {        
00081         callback.attach();
00082     }
00083     void attach(void (*fptr)(void), double d) {
00084         counter = reload = (uint32_t)( d * 1000.0 );
00085         callback.attach(fptr);
00086     }
00087     template<typename T>
00088     void attach(T* tptr, void (T::*mptr)(void), double d) {  
00089         if((mptr != NULL) && (tptr != NULL)) {
00090             counter = reload = (uint32_t)( d * 1000.0 );
00091             callback.attach(tptr, mptr);         
00092         }        
00093     }
00094 };
00095 
00096 // Mimic Mbed's Ticker class but using TIMER2
00097 // (note, only goes to milliseconds level not microseconds!)
00098 
00099 class Ticker2Sys;
00100 extern Ticker2Sys _ticker2Sys;
00101 
00102 class Ticker2 {
00103 protected:
00104     FunctionPointer callback;
00105     uint32_t counter;
00106     uint32_t reload;
00107 public:
00108     Ticker2();
00109     ~Ticker2();
00110     void tick(void);
00111     
00112     void detach(void) {        
00113         callback.attach();
00114     }
00115     void attach(void (*fptr)(void), double d) {
00116         counter = reload = (uint32_t)( d * 1000.0 );
00117         callback.attach(fptr);
00118     }
00119     template<typename T>
00120     void attach(T* tptr, void (T::*mptr)(void), double d) {  
00121         if((mptr != NULL) && (tptr != NULL)) {
00122             counter = reload = (uint32_t)( d * 1000.0 );
00123             callback.attach(tptr, mptr);         
00124         }        
00125     }
00126 };
00127 
00128 // Mimic Mbed's Ticker class but using RIT
00129 // (note, only goes to milliseconds level not microseconds!)
00130 
00131 class TickerRSys;
00132 extern TickerRSys _tickerRSys;
00133 
00134 class Ticker4 {
00135 protected:
00136     FunctionPointer callback;
00137     uint32_t counter;
00138     uint32_t reload;
00139 public:
00140     Ticker4();
00141     ~Ticker4();
00142     void tick(void);
00143     
00144     void detach(void) {        
00145         callback.attach();
00146     }
00147     void attach(void (*fptr)(void), double d) {
00148         counter = reload = (uint32_t)( d * 1000.0 );
00149         callback.attach(fptr);
00150     }
00151     template<typename T>
00152     void attach(T* tptr, void (T::*mptr)(void), double d) {  
00153         if((mptr != NULL) && (tptr != NULL)) {
00154             counter = reload = (uint32_t)( d * 1000.0 );
00155             callback.attach(tptr, mptr);         
00156         }        
00157     }
00158 };
00159 
00160 // Mimic Mbed's Ticker class but using actual Ticker by inheriting.
00161 // This just basically "renames" Ticker to TickerE for consistancy.
00162 
00163 class Ticker3 : public Ticker {
00164 public:
00165     Ticker3() : Ticker() {};
00166 };
00167 
00168 }; // namespace AjK ends.
00169 
00170 #endif