Detailed Android sensor Development complete parsing _android

Well, thanks to the recent development requirements for smart hardware, so the recent days to share the blog is roughly linked to intelligent hardware, like a piece of Bluetooth sharing, I believe that many readers have seen, then today I bring you the knowledge of the Android sensor introduction and use of methods, for the use of sensors , different versions of the Android phone may have larger hardware differences, but same, this article will be through the most common sensors, the infiltration of the church how to use these sensors, lead us to complete this part of the advanced improvement. Let each Android developer be comfortable with the use of the sensor.

Three types of 1.Android sensors

The Android sensor is broadly divided into three types of sensors: Motion (Motion) sensor, Environment (environmental) sensor, Position (Position) sensor.

(1) Motion sensor

This type of sensor measures the acceleration and rotation angles on three axes (x, Y, z). includes several sensors as follows:

Acceleration (accelerometer) sensor, gravity (gravity) sensor, gyroscope (gyroscope) sensor, rotation vector (rotational vector) sensor
Let's look at the coordinates of the sensor world:

The coordinate system of the sensor world

is not already feeling a bit.

(2) Environmental sensors

Such sensors can measure parameters in different environments, such as ambient air temperature and pressure, light intensity and humidity. includes several sensors as follows:

Humidity (barometer) sensor, light (photometer) sensor, temperature (thermometer) sensor

(3) Position sensor

This type of sensor can measure the physical location of the device. includes several sensors as follows:

Directional (orientation) sensors, magnetic (magnetometer) sensors

Once we get to work on the sensor's programming, we'll look at the sensor framework that Android provides for us (the Android Sensor framework, ASF for short).

2.Android Sensor Frame

The Android SDK provides ASF for us to access the sensors built into the current Android device. ASF provides a number of classes and interfaces to help us accomplish a variety of sensor-related tasks. For example:

1 determine which sensors are currently built into the Android device.

2 Determine the technical specifications of a sensor.

3 Obtain the data returned by the sensor, and define the accuracy of the sensor return data.

4 registers and logs out sensor event listeners, which are used to monitor changes in the sensor, and typically data that is returned from the sensor needs to be performed using these listeners.

ASF allows us to access a number of sensor types, some of which are hardware-based sensors, and some are software-based sensors. hardware-based sensors are embedded directly into the Android device in a chip form, and these sensors get data directly from the external environment. software-based sensors are not real hardware chips, and the data returned by software-based sensors is essentially based on hardware-based sensors, which are typically processed two of times. So software-based sensors can also be called virtual or synthetic (synthetic) sensors.

Android has abstracted sensors for each device, where the Sensormanger class is used to control sensors, sensor to describe specific sensors, and sensoreventlistener to monitor changes in sensor values.

(1) Sensormanager class

The instance used to create the sensor service. This class provides a number of methods for accessing and enumerating sensors, registering and unregistering sensor listeners. It also provides constants related to sensor accuracy, scanning frequency, and calibration.

(2) Sensor class

The sensor class provides us with some methods for obtaining sensor technical parameters. such as version, type, manufacturer, etc. For example, the type types of all sensors are as follows:
Note: 1-8 is a hardware sensor, 9 is a software sensor, where the data from the direction sensor comes from gravity and magnetic field sensors, and 10-12 is hardware or software sensors.

Serial Number	sensor	type constants defined in the Sensor class
1	Acceleration Sensor	Type_accelerometer
2	Temperature sensor	Type_ambient_temperature
3	Gyro sensor	Type_gyroscope
4	Light sensor	Type_light
5	magnetic field Sensor	Type_magnetic_field
6	Pressure Transducer	Type_pressure
7	Proximity sensor	Type_proximity
8	Humidity sensor	Type_relative_humidity
9	Directional sensor	Type_orientation
10	Gravity sensor	Type_gravity
11	Linear acceleration Sensor	Type_linear_acceleration
12	Rotation vector sensor	Type_rotation_vector

(3) Sensorevent class

The system uses this class to create a sensor event object. This object can provide information about the sensor event. The Sensor event object includes information about the original sensor postback data, the sensor type, the precision of the data, and when the event was triggered.

(4) Sensoreventlistener interface

The interface contains two callback methods, which are called when the sensor's return value or precision changes.

/**
 * Sensor accuracy Change callback
/@Override public
void onaccuracychanged (Sensor Sensor, int accuracy) {
}
/**
 * Callback when sensor data changes
/@Override public
void Onsensorchanged (Sensorevent event) {
}

When we get here, we can work on sensor development.

3. Obtain the Sensor technical parameter

Down we'll write code to get the sensor technical parameters for our phone.

TextView tvsensors = (TextView) Findviewbyid (r.id.tv_sensors);
Get sensor Sensormanager Object
sensormanager Sensormanager = (sensormanager) getsystemservice (sensor_service);
list<sensor> sensors = sensormanager.getsensorlist (sensor.type_all);
for (Sensor sensor:sensors) {
  tvsensors.append (sensor.getname () + "\ n");
}

Run it first to see the effect:

Looks like my cell phone sensor still a lot of, haha. Note that the entity machine test must be used here.

Let's take a look at the composition and usage of the motion sensor, environment sensor and position sensor respectively.

4. Motion sensor's composition and the use method

All motion sensors return three floating-point values (via an array of length 3), but for different sensors, these three are just different meanings. For example, for an acceleration sensor, data from three axes is returned. For gyro sensors, the rotational angular speed of the three axes is returned.

Note: The motion sensor itself is not normally used to monitor the location of the device, and the location of the device needs to be monitored by other types of sensors, such as a magnetic field sensor.

(1) Acceleration sensor

Acceleration sensors need to be used in conjunction with gravity sensors to reduce acceleration by gravity. First you need to implement the Sensoreventlistener interface, add a callback method, then get the Sensor Sensormanager object, register the sensor, and then we can monitor the sensor changes. The sample code is as follows:

public class Sensoractivity extends Appcompatactivity implements Sensoreventlistener {private TextView Tvaccelerometer
  ;
  Private Sensormanager Msensormanager;
  Private float[] Gravity = new float[3];
    @Override protected void OnCreate (Bundle savedinstancestate) {super.oncreate (savedinstancestate);
    Setcontentview (R.layout.activity_sensor);
    Tvaccelerometer = (TextView) Findviewbyid (r.id.tv_accelerometer);
  Get Sensor Sensormanager Object Msensormanager = (Sensormanager) getsystemservice (Sensor_service); /** * Callback/@Override public void onaccuracychanged (Sensor Sensor, int accuracy) {}/** * sensing when sensor accuracy changes Callback/@Override public void onsensorchanged (Sensorevent event) {//Judge Sensor class switch (event.sensor.getTy) when data changes
        PE ()) {case Sensor.type_accelerometer://Acceleration Sensor final float alpha = (float) 0.8;
        GRAVITY[0] = Alpha * Gravity[0] + (1-alpha) * event.values[0]; GRAVITY[1] = Alpha * Gravity[1] + (1-alpha) * EVENT.VALUES[1];

        GRAVITY[2] = Alpha * gravity[2] + (1-alpha) * event.values[2]; String Accelerometer = "acceleration sensor \ n" + "x:" + (Event.values[0]-gravity[0]) + "\ n" + "Y:" + (EVENT.V
        ALUES[1]-gravity[1]) + "\ n" + "Z:" + (Event.values[2]-gravity[2]);
        Tvaccelerometer.settext (accelerometer);
      The gravitational acceleration 9.81m/s^2, only under the action of gravity, the free falling acceleration break;
        Case sensor.type_gravity://gravity sensor gravity[0] = event.values[0];//Unit m/s^2 gravity[1] = event.values[1];
        GRAVITY[2] = event.values[2];
      Break
    Default:break;
    }/** * Interface to get focus, button can be clicked when callback/protected void Onresume () {super.onresume (); Register Acceleration Sensor Msensormanager.registerlistener (This, msensormanager.getdefaultsensor (sensor.type_accelerometer),// Sensor type type SENSORMANAGER.SENSOR_DELAY_UI)//Acquisition frequency//Registration Gravity Sensor Msensormanager.registerlistener (this, MS Ensormanager.getdefaultsensor (sensor.type_gravity), sensormanager.sensor_delay_fastest);
    /** * Suspend activity, interface gain focus, button can be clicked when callback/@Override protected void OnPause () {super.onpause ();
  Msensormanager.unregisterlistener (this);

 }

}

We put the phone level face up on the table and look at the effect chart:

We can see positive and negative values, so what's the positive? What is a negative value?

The device is pushed along the x-axis, and the x-axis acceleration is positive.

The device pushes along the y-axis, and the y-axis acceleration is positive.

If you push along the z-axis, the phone is positioned relative to the table horizontally upward, and the z-axis acceleration is positive. Driven by a m/s^2 acceleration at the bottom toward the top, the z-axis has an acceleration of a + 9.81, so if the actual acceleration is calculated (offsetting the gravitational acceleration), it needs to be reduced by 9.81.

5. The composition of the position sensor and the use method

Android provides a magnetic field sensor and a directional sensor to determine the location of the device, as well as a sensor (proximity sensor) to measure the distance from the front of the device to a nearby object.

Proximity sensors are common in mobile phones. When you answer the phone, the screen is the adjacent sensor used. The directional sensor is software-based, and the return data of the sensor comes from the accelerometer and the magnetic field sensor.

Position sensors are useful for determining the physical location of a device in the real world. For example, a magnetic field sensor and an accelerometer can be combined to measure the position of the device relative to the geomagnetic North Pole, and a directional sensor can be used to determine the position of the current device relative to its own reference frame.

Both the magnetic field sensor and the directional sensor return a value of 3 values (sensorevent.values), while the proximity sensor returns only 1 values.

Let's take a specific look at their return values:

Direction sensor:

• Sensorevent.values[0]: The angle of rotation around the z axis. If the y-axis (the direction of the cell phone is normal) is pointing north, the value is 0, if the y-axis points south, the 180,y axis points to the east, the value is 90, and if the y-axis points to the West, the value is 270.
  
• SENSOREVENT.VALUES[1]: The degree of rotation around the x axis. When the positive direction of the y-axis is directed from the z-axis, the value is positive. Conversely, a negative value. The value changes between 180 and 180.
  
• SENSOREVENT.VALUES[2]: The degree of rotation around the y axis. When the positive direction of the x-axis is directed from the z-axis, the value is positive. Conversely, a negative value. The value changes between 180 and 180.
  

magnetic field Sensor:

• Sensorevent.values[0]: Magnetic force along the x-axis (Μt,millitesla)
• SENSOREVENT.VALUES[1]: Magnetic force along the y-axis (Μt,millitesla)
• SENSOREVENT.VALUES[2]: Magnetic force along the y-axis (Μt,millitesla)
  

Proximity sensor:

SENSOREVENT.VALUES[0]: Cell phone frontal distance from proximity to physical distance (CM)

(1) Proximity sensor

Here the proximity sensor works as a sample project, and other sensors are similar.

public class Sensoractivity extends Appcompatactivity implements Sensoreventlistener {private TextView tvproximity;
  Private Sensormanager Msensormanager;
    @Override protected void OnCreate (Bundle savedinstancestate) {super.oncreate (savedinstancestate);
    Setcontentview (R.layout.activity_motion_sensor);
    Tvproximity = (TextView) Findviewbyid (r.id.tv_proximity);
  Get Sensor Sensormanager Object Msensormanager = (Sensormanager) getsystemservice (Sensor_service); /** * Callback/@Override public void onaccuracychanged (Sensor Sensor, int accuracy) {}/** * sensing when sensor accuracy changes Callback/@Override public void onsensorchanged (Sensorevent event) {//Judge Sensor class switch (event.sensor.getTy) when data changes
        PE ()) {case sensor.type_proximity://Proximity sensor Tvproximity.settext (string.valueof (event.values[0));
      Break
    Default:break;
    }/** * Interface to get focus, button can be clicked when callback/protected void Onresume () {super.onresume (); Register Proximity Sensor MsenSormanager.registerlistener (This, msensormanager.getdefaultsensor (sensor.type_proximity), SensorManager.SE
  NSOR_DELAY_UI);
    /** * Suspend activity, interface gain focus, button can be clicked when callback/@Override protected void OnPause () {super.onpause ();
  Msensormanager.unregisterlistener (this);

 }

}

Run the program, I interrupted the proximity of the sensor, look at the effect of the picture:

0.0 is when I block the value of the proximity sensor, 8.0 is the value when I move my hand away.

Here we look at a comparison of the sensor, and nature is closely related.

6. Environment sensor composition and use method

Android provides sensors for detecting different external environments. For example, you can detect ambient air humidity, light, air pressure and temperature, these sensors are hardware-based sensors. In addition to light sensors, other sensors are rare in common Android devices. So if you are using an ambient sensor, it is best to run the sensor that the current Android device supports.

(1) The return value of the environment sensor

Most motion sensors and position sensors return multiple values, and all ambient sensors return only one value:

sensor	Type value	return value	units
Temperature sensor	Type_ambient_temperature	Event.values[0]	°c
Pressure Transducer	Type_pressure	Event.values[0]	Hpa
Light sensor	Type_light	Event.values[0]	Lx
Humidity sensor	Type_relative_humidity	Event.values[0]	RH (%)

Note: The values returned by the ambient sensor are rarely disturbed by the noise, and the action and position sensors often need to eliminate the effects of the noise. For example, the acceleration sensor eliminates the effect of gravity on its return value.

(2) light sensor return data

The strongest light intensity (estimated only in the desert area to reach this value) public
static final float Light_sunlight_max = 120000.0f;
The intensity of direct sunlight in cloudless skies public
static final float light_sunlight = 110000.0f;
There is sunshine, but the intensity of some rays is offset by clouds public
static final float light_shade = 20000.0f;
Cloudy light intensity public  
static final float light_overcast = 10000.0f;
The light intensity of the sun just Rising (sunrise) is public
static final float light_sunrise = 400.0f;
In rainy days, the intensity of light when there is no sun public
static final float light_cloudy = 100.0f;
The intensity of light at night when there is a moon public
static final float light_fullmoon = 0.25f;
At night there is no moon when the intensity of light (of course, there can be no street lamp, is dark) public
static final float light_no_moon = 0.001f;

The use of environmental sensors and motion, position sensors are similar, in the time no longer repeat.

I believe that through this study, everyone's development standards will have a certain improvement, and everyone's improvement is my most gratifying things. We also hope that we can support the cloud-dwelling community.