defines changed from TARGET_LPC1768 to TARGET_LPC176X to support LPC1769 target
Fork of FastAnalogIn by
FastAnalogIn.h
00001 #ifndef FASTANALOGIN_H 00002 #define FASTANALOGIN_H 00003 00004 /* 00005 * Includes 00006 */ 00007 #include "mbed.h" 00008 #include "pinmap.h" 00009 00010 #if !defined TARGET_LPC176X && !defined TARGET_KLXX && !defined TARGET_LPC408X && !defined TARGET_LPC11UXX && !defined TARGET_K20D5M 00011 #error "Target not supported" 00012 #endif 00013 00014 /** A class similar to AnalogIn, only faster, for LPC176X, LPC408X and KLxx 00015 * 00016 * AnalogIn does a single conversion when you read a value (actually several conversions and it takes the median of that). 00017 * This library runns the ADC conversion automatically in the background. 00018 * When read is called, it immediatly returns the last sampled value. 00019 * 00020 * LPC176X / LPC4088 00021 * Using more ADC pins in continuous mode will decrease the conversion rate (LPC176X:200kHz/LPC4088:400kHz). 00022 * If you need to sample one pin very fast and sometimes also need to do AD conversions on another pin, 00023 * you can disable the continuous conversion on that ADC channel and still read its value. 00024 * 00025 * KLXX 00026 * Multiple Fast instances can be declared of which only ONE can be continuous (all others must be non-continuous). 00027 * 00028 * When continuous conversion is disabled, a read will block until the conversion is complete 00029 * (much like the regular AnalogIn library does). 00030 * Each ADC channel can be enabled/disabled separately. 00031 * 00032 * IMPORTANT : It does not play nicely with regular AnalogIn objects, so either use this library or AnalogIn, not both at the same time!! 00033 * 00034 * Example for the KLxx processors: 00035 * @code 00036 * // Print messages when the AnalogIn is greater than 50% 00037 * 00038 * #include "mbed.h" 00039 * 00040 * FastAnalogIn temperature(PTC2); //Fast continuous sampling on PTC2 00041 * FastAnalogIn speed(PTB3, 0); //Fast non-continuous sampling on PTB3 00042 * 00043 * int main() { 00044 * while(1) { 00045 * if(temperature > 0.5) { 00046 * printf("Too hot! (%f) at speed %f", temperature.read(), speed.read()); 00047 * } 00048 * } 00049 * } 00050 * @endcode 00051 * Example for the LPC176X processor: 00052 * @code 00053 * // Print messages when the AnalogIn is greater than 50% 00054 * 00055 * #include "mbed.h" 00056 * 00057 * FastAnalogIn temperature(p20); 00058 * 00059 * int main() { 00060 * while(1) { 00061 * if(temperature > 0.5) { 00062 * printf("Too hot! (%f)", temperature.read()); 00063 * } 00064 * } 00065 * } 00066 * @endcode 00067 */ 00068 class FastAnalogIn { 00069 00070 public: 00071 /** Create a FastAnalogIn, connected to the specified pin 00072 * 00073 * @param pin AnalogIn pin to connect to 00074 * @param enabled Enable the ADC channel (default = true) 00075 */ 00076 FastAnalogIn( PinName pin, bool enabled = true ); 00077 00078 ~FastAnalogIn( void ) 00079 { 00080 disable(); 00081 } 00082 00083 /** Enable the ADC channel 00084 * 00085 * @param enabled Bool that is true for enable, false is equivalent to calling disable 00086 */ 00087 void enable(bool enabled = true); 00088 00089 /** Disable the ADC channel 00090 * 00091 * Disabling unused channels speeds up conversion in used channels. 00092 * When disabled you can still call read, that will do a single conversion (actually two since the first one always returns 0 for unknown reason). 00093 * Then the function blocks until the value is read. This is handy when you sometimes needs a single conversion besides the automatic conversion 00094 */ 00095 void disable( void ); 00096 00097 /** Returns the raw value 00098 * 00099 * @param return Unsigned integer with converted value 00100 */ 00101 unsigned short read_u16( void ); 00102 00103 /** Returns the scaled value 00104 * 00105 * @param return Float with scaled converted value to 0.0-1.0 00106 */ 00107 float read( void ) 00108 { 00109 unsigned short value = read_u16(); 00110 return (float)value * (1.0f/65535.0f); 00111 } 00112 00113 /** An operator shorthand for read() 00114 */ 00115 operator float() { 00116 return read(); 00117 } 00118 00119 00120 private: 00121 bool running; 00122 char ADCnumber; 00123 volatile uint32_t *datareg; 00124 }; 00125 00126 #endif
Generated on Thu Jul 28 2022 08:58:48 by 1.7.2