AnalogIn

Use the AnalogIn API to read an external voltage applied to an analog input pin.

Tips:

API

 
 /* mbed Microcontroller Library
  * Copyright (c) 2006-2013 ARM Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #ifndef MBED_ANALOGIN_H
 #define MBED_ANALOGIN_H
 
 #include "platform/platform.h"
 
 #if defined (DEVICE_ANALOGIN) || defined(DOXYGEN_ONLY)
 
 #include "hal/analogin_api.h"
 #include "platform/SingletonPtr.h"
 #include "platform/PlatformMutex.h"
 
 namespace mbed {
 /** \addtogroup drivers */
 
 /** An analog input, used for reading the voltage on a pin
  *
  * @note Synchronization level: Thread safe
  *
  * Example:
  * @code
  * // Print messages when the AnalogIn is greater than 50%
  *
  * #include "mbed.h"
  *
  * AnalogIn temperature(p20);
  *
  * int main() {
  * while(1) {
  * if(temperature > 0.5) {
  * printf("Too hot! (%f)", temperature.read());
  * }
  * }
  * }
  * @endcode
  * @ingroup drivers
  */
 class AnalogIn {
 
 public:
 
  /** Create an AnalogIn, connected to the specified pin
  *
  * @param pin AnalogIn pin to connect to
  */
  AnalogIn(PinName pin) {
  lock();
  analogin_init(&_adc, pin);
  unlock();
  }
 
  /** Read the input voltage, represented as a float in the range [0.0, 1.0]
  *
  * @returns A floating-point value representing the current input voltage, measured as a percentage
  */
  float read() {
  lock();
  float ret = analogin_read(&_adc);
  unlock();
  return ret;
  }
 
  /** Read the input voltage, represented as an unsigned short in the range [0x0, 0xFFFF]
  *
  * @returns
  * 16-bit unsigned short representing the current input voltage, normalised to a 16-bit value
  */
  unsigned short read_u16() {
  lock();
  unsigned short ret = analogin_read_u16(&_adc);
  unlock();
  return ret;
  }
 
  /** An operator shorthand for read()
  *
  * The float() operator can be used as a shorthand for read() to simplify common code sequences
  *
  * Example:
  * @code
  * float x = volume.read();
  * float x = volume;
  *
  * if(volume.read() > 0.25) { ... }
  * if(volume > 0.25) { ... }
  * @endcode
  */
  operator float() {
  // Underlying call is thread safe
  return read();
  }
 
  virtual ~AnalogIn() {
  // Do nothing
  }
 
 protected:
 
  virtual void lock() {
  _mutex->lock();
  }
 
  virtual void unlock() {
  _mutex->unlock();
  }
 
  analogin_t _adc;
  static SingletonPtr<PlatformMutex> _mutex;
 };
 
 } // namespace mbed
 
 #endif
 
 #endif
 
Definition: AnalogIn.h:52
unsigned short read_u16()
Definition: AnalogIn.h:82
AnalogIn(PinName pin)
Definition: AnalogIn.h:60
float read()
Definition: AnalogIn.h:70
Definition: AnalogIn.h:27

Hello World!

 


/* mbed Example Program
 * Copyright (c) 2006-2014 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "mbed.h"

// Initialize a pins to perform analog input and digital output fucntions
AnalogIn   ain(A0);
DigitalOut dout(LED1);

int main(void)
{
    while (1) {
        // test the voltage on the initialized analog pin
        //  and if greater than 0.3 * VCC set the digital pin
        //  to a logic 1 otherwise a logic 0
        if(ain > 0.3f) {
            dout = 1;
        } else {
            dout = 0;
        }
        
        // print the percentage and 16 bit normalized values
        printf("percentage: %3.3f%%\n", ain.read()*100.0f);
        printf("normalized: 0x%04X \n", ain.read_u16());
        wait(0.2f);
    }
}

Examples

Example one

Control an R/C servo with analog input.

 


#include "mbed.h"

AnalogIn position(A0);
PwmOut servo(D3);

int main() {
    // servo requires a 20ms period    
    servo.period(0.020f);
    while (1) {
        // servo position determined by a pulse width between 1-2ms
        servo.pulsewidth(0.001f + 0.001f * position);
    }
}

Example two

This example shows AnalogIn reading 16-bit normalized samples.

 


#include "mbed.h"

AnalogIn input(A0);

int main() {
    uint16_t samples[1024];

    for(int i=0; i<1024; i++) {
        samples[i] = input.read_u16();
        wait(0.001f);
    }

    printf("Results:\n");
    for(int i=0; i<1024; i++) {
        printf("%d, 0x%04X\n", i, samples[i]);
    }
}   

Example three

The example below shows a visual volt meter using LEDs.

 


#include "mbed.h"

AnalogIn ain(A0);
DigitalOut led1(LED1);
DigitalOut led2(LED2);
DigitalOut led3(LED3);
DigitalOut led4(LED4);

int main() {
    while (1){
        led1 = (ain > 0.2f) ? 1 : 0;
        led2 = (ain > 0.4f) ? 1 : 0;
        led3 = (ain > 0.6f) ? 1 : 0;
        led4 = (ain > 0.8f) ? 1 : 0;
    }
}