private boolean _isSupported(Sensor sensor) {
boolean isSupported = !(sensor == null);
if (isSupported) {
Out.print("Sensor " + sensor.getName() + " type " + sensor.getType() + " found.");
} else {
Out.print("Sensor " + sensor.getName() + " type " + sensor.getType() + " not found.");
}
return isSupported;
}
// public void onSensorChanged(int sensor, float[] values) {
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
synchronized (this) {
if (sensor.getType() == Sensor.TYPE_ORIENTATION) {
} // 如果是姿势传感器信息改变 跳过
else {
int j = (sensor.getType() == Sensor.TYPE_ACCELEROMETER) ? 1 : 0;
if (j == 1) {
float vSum = 0;
for (int i = 0; i < 3; i++) {
final float v = mYOffset + event.values[i] * mScale[j];
vSum += v;
}
int k = 0;
// 将 x、y、z三轴的加速度加起来然后去平均值
float v = vSum / 3;
// 根据此刻得到的值与上一次数据比对 more equal less 分别记录为1 0 -1
float direction = (v > mLastValues[k] ? 1 : (v < mLastValues[k] ? -1 : 0));
if (direction == -mLastDirections[k]) {
// 方向相反改变
int extType = (direction > 0 ? 0 : 1); // minumum or maximum?
mLastExtremes[extType][k] = mLastValues[k];
float diff = Math.abs(mLastExtremes[extType][k] - mLastExtremes[1 - extType][k]);
if (diff > mLimit) {
boolean isAlmostAsLargeAsPrevious = diff > (mLastDiff[k] * 2 / 3);
boolean isPreviousLargeEnough = mLastDiff[k] > (diff / 3);
boolean isNotContra = (mLastMatch != 1 - extType);
if (isAlmostAsLargeAsPrevious && isPreviousLargeEnough && isNotContra) {
// 能够判断此时正在走路
Log.i(TAG, "step");
for (StepListener stepListener : mStepListeners) {
stepListener.onStep();
}
mLastMatch = extType;
} else {
mLastMatch = -1;
}
}
mLastDiff[k] = diff;
}
mLastDirections[k] = direction;
mLastValues[k] = v;
}
}
}
}
private void saveAccelerometerDevice(Sensor acc) {
Cursor accelInfo =
getContentResolver().query(Accelerometer_Sensor.CONTENT_URI, null, null, null, null);
if (accelInfo == null || !accelInfo.moveToFirst()) {
ContentValues rowData = new ContentValues();
rowData.put(
Accelerometer_Sensor.DEVICE_ID,
Aware.getSetting(getApplicationContext(), Aware_Preferences.DEVICE_ID));
rowData.put(Accelerometer_Sensor.TIMESTAMP, System.currentTimeMillis());
rowData.put(Accelerometer_Sensor.MAXIMUM_RANGE, acc.getMaximumRange());
rowData.put(Accelerometer_Sensor.MINIMUM_DELAY, acc.getMinDelay());
rowData.put(Accelerometer_Sensor.NAME, acc.getName());
rowData.put(Accelerometer_Sensor.POWER_MA, acc.getPower());
rowData.put(Accelerometer_Sensor.RESOLUTION, acc.getResolution());
rowData.put(Accelerometer_Sensor.TYPE, acc.getType());
rowData.put(Accelerometer_Sensor.VENDOR, acc.getVendor());
rowData.put(Accelerometer_Sensor.VERSION, acc.getVersion());
try {
getContentResolver().insert(Accelerometer_Sensor.CONTENT_URI, rowData);
Intent accel_dev = new Intent(ACTION_AWARE_ACCELEROMETER);
accel_dev.putExtra(EXTRA_SENSOR, rowData);
sendBroadcast(accel_dev);
if (Aware.DEBUG) Log.d(TAG, "Accelerometer device:" + rowData.toString());
} catch (SQLiteException e) {
if (Aware.DEBUG) Log.d(TAG, e.getMessage());
} catch (SQLException e) {
if (Aware.DEBUG) Log.d(TAG, e.getMessage());
}
} else accelInfo.close();
}
@Override
public void onSensorChanged(SensorEvent sensorEvent) {
Sensor mySensor = sensorEvent.sensor;
if (mySensor.getType() == Sensor.TYPE_ACCELEROMETER) {
float x = sensorEvent.values[0];
float y = sensorEvent.values[1];
float z = sensorEvent.values[2];
long curTime = System.currentTimeMillis();
if ((curTime - lastUpdate) > 100) {
long diffTime = (curTime - lastUpdate);
lastUpdate = curTime;
float speed = Math.abs(x + y + z - last_x - last_y - last_z) / diffTime * 10000;
if (speed > SHAKE_THRESHOLD) {
mShakeListener.onShake();
}
last_x = x;
last_y = y;
last_z = z;
}
}
}
protected void ativaListenersSensores(ArrayList<Sensor> sensor) {
for (Sensor aux : sensor) {
aux = sm.getDefaultSensor(aux.getType());
sm.registerListener(this, aux, SensorManager.SENSOR_DELAY_NORMAL);
}
}
@SuppressWarnings("deprecation")
public static double getSensorChartMinY(Sensor sensor) {
double yMin;
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
yMin = -20.0;
break;
case Sensor.TYPE_GYROSCOPE:
yMin = -40.0;
break;
case Sensor.TYPE_MAGNETIC_FIELD:
yMin = -30.0;
break;
case Sensor.TYPE_ORIENTATION:
yMin = -50.0;
break;
case Sensor.TYPE_TEMPERATURE:
yMin = -40.0;
break;
case Sensor.TYPE_LINEAR_ACCELERATION:
yMin = -30.0;
break;
case Sensor.TYPE_GRAVITY:
yMin = -10.0;
break;
case Sensor.TYPE_ROTATION_VECTOR:
yMin = -5.0;
break;
default:
yMin = 0.0;
break;
}
return yMin;
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
if (sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
mHasInterference = (accuracy < SensorManager.SENSOR_STATUS_ACCURACY_HIGH);
notifyAccuracyChanged();
}
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// присвоили менеджеру работу с серсором
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
// создали список сенсоров для записи и сортировки
List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
// делаем проверку если больше нуля значит все хорошо и начинаем обрабатывать работу датчика
if (sensors.size() > 0) {
// форич для зацикливания работы, что бы не единожды выполнялось, а постоянно
for (Sensor sensor : sensors) {
// берем данные с акселерометра
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
// если пусто значит возвращаем значения сенсора
if (mAccelerometerSensor == null) mAccelerometerSensor = sensor;
break;
default:
break;
}
}
}
// привязываем наши объекты к нашей разметке
mXValueText = (TextView) findViewById(R.id.value_x);
mYValueText = (TextView) findViewById(R.id.value_y);
mZValueText = (TextView) findViewById(R.id.value_z);
}
/** {@inheritDoc} */
public void onAccuracyChanged(Sensor sensor, int accuracy) {
if (sensor == null) throw new NullPointerException();
if (sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD
&& accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) {
Log.e(TAG, "Compass data unreliable");
}
}
@Override
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
float accelerometer_x = event.values[0];
Log.d("SENSORS10", "accelerometer_x = " + accelerometer_x);
}
}
/**
* onSensorChanged
*
* @param event
*/
@Override
public void onSensorChanged(SensorEvent event) {
/** Muestreo de los datos una vez se vaya modificando el valor */
Sensor sensor = event.sensor;
float[] values = event.values;
int value = -1;
/** los valores se almacenan en el vector values. */
if (values.length > 0) {
value = (int) values[0];
}
if (sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
textView.setText("Número de pasos : " + value);
} else if (sensor.getType() == Sensor.TYPE_STEP_DETECTOR) {
/** Prueba. Sólo permite el valor 1 para el paso dado */
textView.setText("Número de pasos : " + value);
}
}
public void testSensorOperations() {
// Because we can't know every sensors unit details, so we can't assert
// get values with specified values.
List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
assertNotNull(sensors);
Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
boolean hasAccelerometer =
getContext()
.getPackageManager()
.hasSystemFeature(PackageManager.FEATURE_SENSOR_ACCELEROMETER);
// accelerometer sensor is optional
if (hasAccelerometer) {
assertEquals(Sensor.TYPE_ACCELEROMETER, sensor.getType());
assertSensorValues(sensor);
} else {
assertNull(sensor);
}
sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
boolean hasCompass =
getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_SENSOR_COMPASS);
// compass sensor is optional
if (hasCompass) {
assertEquals(Sensor.TYPE_MAGNETIC_FIELD, sensor.getType());
assertSensorValues(sensor);
} else {
assertNull(sensor);
}
sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
// orientation sensor is required if the device can physically implement it
if (hasCompass && hasAccelerometer) {
assertEquals(Sensor.TYPE_ORIENTATION, sensor.getType());
assertSensorValues(sensor);
}
sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_TEMPERATURE);
// temperature sensor is optional
if (sensor != null) {
assertEquals(Sensor.TYPE_TEMPERATURE, sensor.getType());
assertSensorValues(sensor);
}
}
@Kroll.setProperty
@Kroll.method
protected int[] getSensorList(int type) {
List<Sensor> sensors = sensorManager.getSensorList(type);
int[] list = new int[sensors.size()];
for (int i = 0; i < sensors.size(); i++) {
Sensor sensor = sensors.get(i);
list[i] = sensor.getType();
}
return list;
}
@Override
public void onSensorChanged(SensorEvent event) {
float[] values = event.values;
Sensor sensor = event.sensor;
synchronized (this) {
if (sensor.getType() == Sensor.TYPE_PROXIMITY) {
pValue.setText(getString(R.string.proximity_timer_value, values[0] + ""));
updateProximitySensorMode(values[0]);
}
}
}
@Override
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
try {
thing.setProperty("Accelerometer", event.values[0]);
} catch (Exception e) {
e.printStackTrace();
}
} else if (sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
try {
thing.setProperty("MagneticField", event.values[0]);
} catch (Exception e) {
e.printStackTrace();
}
}
try {
thing.updateSubscribedProperties(5000);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
if (sensor.getType() == sensor.TYPE_ACCELEROMETER) {
cyaccel = event.values[1];
czaccel = event.values[2];
if (cyaccel > cymax) {
cymax = cyaccel;
cymaxview.setText(Float.toString(cymax));
}
if (czaccel > czmax) {
czmax = czaccel;
czmaxview.setText(Float.toString(czmax));
}
}
}
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
float[] values = event.values;
int value = -1;
if (values.length > 0) {
value = (int) values[0];
}
if (sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
RebootSteps.setText(" " + value);
} /*else if (sensor.getType() == Sensor.TYPE_STEP_DETECTOR) {
// For test only.
textView.setText("Step Detector Detected : " + value);
}*/
}
@Kroll.setProperty
@Kroll.method
protected KrollDict getSensorInfos(int type) {
Sensor sensor = sensorManager.getDefaultSensor(type);
KrollDict data = new KrollDict();
if (null != sensor) {
data.put("name", sensor.getName());
data.put("constant", sensor.getType());
data.put("version", sensor.getVersion());
data.put("resolution", sensor.getResolution());
data.put("power", sensor.getPower());
data.put("vendor", sensor.getVendor());
data.put("maximumRange", sensor.getMaximumRange());
data.put("minDelay", sensor.getMinDelay());
}
return data;
}
@Override
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
if (sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
if (first) {
first = false;
System.out.println("error first");
// Toast.makeText(this, "sensor result", Toast.LENGTH_LONG).show();
count1 = Float.parseFloat(String.valueOf(event.values[0]));
}
if (activityRunning) {
System.out.println("error later");
// Toast.makeText(this, "sensor value 1", Toast.LENGTH_LONG).show();
drawView.invalidate();
count.setText((Float.parseFloat(String.valueOf(event.values[0])) - count1) + "");
}
}
if (event.sensor == mAccelerometer) {
System.arraycopy(event.values, 0, mLastAccelerometer, 0, event.values.length);
mLastAccelerometerSet = true;
} else if (event.sensor == mMagnetometer) {
System.arraycopy(event.values, 0, mLastMagnetometer, 0, event.values.length);
mLastMagnetometerSet = true;
}
if (mLastAccelerometerSet && mLastMagnetometerSet) {
Toast.makeText(this, "I am here", Toast.LENGTH_LONG).show();
SensorManager.getRotationMatrix(mR, null, mLastAccelerometer, mLastMagnetometer);
SensorManager.getOrientation(mR, mOrientation);
float azimuthInRadians = mOrientation[0];
float azimuthInDegress = (float) (Math.toDegrees(azimuthInRadians) + 360) % 360;
angle.setText(azimuthInRadians + " radians and " + azimuthInDegress + " degrees");
float diff = Math.abs(azimuthInDegress - previousdegree);
if (diff > 90) {
previousdegree = azimuthInDegress;
if (azimuthInDegress < 45 || azimuthInDegress > 315) {
drawView.current = DrawView.Side.North;
} else if (azimuthInDegress > 45 || azimuthInDegress < 135) {
drawView.current = DrawView.Side.East;
} else if (azimuthInDegress > 135 || azimuthInDegress < 225) {
drawView.current = DrawView.Side.South;
} else {
drawView.current = DrawView.Side.West;
}
}
}
}
@SuppressWarnings("deprecation")
public static double getSensorChartMaxX(Sensor sensor) {
double xMax;
switch (sensor.getType()) {
case Sensor.TYPE_LIGHT:
case Sensor.TYPE_PRESSURE:
case Sensor.TYPE_PROXIMITY:
case Sensor.TYPE_TEMPERATURE:
xMax = 50;
break;
default:
xMax = 2000;
break;
}
return xMax;
}
@SuppressWarnings("deprecation")
public static boolean isPhysicalSensor(Sensor sensor) {
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
case Sensor.TYPE_MAGNETIC_FIELD:
case Sensor.TYPE_GYROSCOPE:
case Sensor.TYPE_LIGHT:
case Sensor.TYPE_PRESSURE:
case Sensor.TYPE_TEMPERATURE:
case Sensor.TYPE_PROXIMITY:
case 9836800: // TYPE_VOLLEY_GESTURE
case 9836801: // TYPE_HALL_DEVICE
return true;
default:
return false;
}
}
@Override
public void onSensorChanged(SensorEvent event) {
Sensor mySensor = event.sensor;
if (mySensor.getType() == SensorManager.SENSOR_ACCELEROMETER) {
long curTime = System.currentTimeMillis();
if ((curTime - lastForce) > SHAKE_TIMEOUT) {
shakeCount = 0;
}
// Only allow one update every 100ms.
if ((curTime - lastUpdate) > TIME_THRESHOLD) {
long diffTime = (curTime - lastUpdate);
lastUpdate = curTime;
float x = event.values[SensorManager.DATA_X];
float y = event.values[SensorManager.DATA_Y];
float z = event.values[SensorManager.DATA_Z];
float speed = Math.abs(x + y + z - last_x - last_y - last_z) / diffTime * 10000;
if (speed > FORCE_THRESHOLD) {
if ((++shakeCount >= SHAKE_COUNT) && (curTime - lastShake > SHAKE_DURATION)) {
lastShake = curTime;
shakeCount = 0;
if (sensorMgr != null) {
for (ShakeEventListener listener : listeners) {
listener.onShakeEvent();
}
}
}
lastForce = curTime;
}
lastForce = curTime;
last_x = x;
last_y = y;
last_z = z;
}
}
}
/**
* Returns String value for the sensor type
*
* @param sensor the sensor type
* @return String value for the sensor type
*/
@SuppressWarnings("deprecation")
public static String getSensorTypeString(Sensor sensor) {
String sensorTypeString;
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
sensorTypeString = "ACCEL";
break;
case Sensor.TYPE_GYROSCOPE:
sensorTypeString = "GYRO";
break;
case Sensor.TYPE_LIGHT:
sensorTypeString = "LIGHT";
break;
case Sensor.TYPE_MAGNETIC_FIELD:
sensorTypeString = "MAG";
break;
case Sensor.TYPE_ORIENTATION:
sensorTypeString = "ORI";
break;
case Sensor.TYPE_PRESSURE:
sensorTypeString = "PRESS";
break;
case Sensor.TYPE_PROXIMITY:
sensorTypeString = "PROX";
break;
case Sensor.TYPE_TEMPERATURE:
sensorTypeString = "TEMP";
break;
case Sensor.TYPE_LINEAR_ACCELERATION:
sensorTypeString = "L.ACCEL";
break;
case Sensor.TYPE_GRAVITY:
sensorTypeString = "GRAVITY";
break;
case Sensor.TYPE_ROTATION_VECTOR:
sensorTypeString = "ROT VEC";
break;
default:
// sensorTypeString = "UNKNOWN";
sensorTypeString = sensor.getName();
break;
}
return sensorTypeString;
}
public static int pickIcon(Sensor sensor) {
switch (sensor.getType()) {
case Sensor.TYPE_GRAVITY:
return R.drawable.ic_gravity;
case Sensor.TYPE_RELATIVE_HUMIDITY:
return R.drawable.ic_humidity;
case Sensor.TYPE_LIGHT:
return R.drawable.ic_light;
case Sensor.TYPE_SIGNIFICANT_MOTION:
return R.drawable.ic_motion;
case Sensor.TYPE_PRESSURE:
return R.drawable.ic_pressure;
case Sensor.TYPE_STEP_COUNTER:
case Sensor.TYPE_STEP_DETECTOR:
return R.drawable.ic_step;
}
return R.drawable.ic_sensor;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
List<Sensor> sensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);
for (Sensor s : sensorList) {
Log.d("sensor", "Name=" + s.getName());
Log.d("sensor", "Vendor=" + s.getVendor());
Log.d("sensor", "Version=" + s.getVersion());
Log.d("sensor", "MaximumRange=" + s.getMaximumRange());
Log.d("sensor", "MinDelay=" + s.getMinDelay());
Log.d("sensor", "Power=" + s.getPower());
Log.d("sensor", "Type=" + s.getType());
}
}
/**
* Return string value for the sensor unit
*
* @param sensor the sensor type
* @return String value for the sensor unit
*/
@SuppressWarnings("deprecation")
public static String getSensorUnitString(Sensor sensor) {
String sensorUnitString;
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
sensorUnitString = "Acceleration(m/sec^2)";
break;
case Sensor.TYPE_GYROSCOPE:
sensorUnitString = "Angular Velocity(rad/sec)";
break;
case Sensor.TYPE_LIGHT:
sensorUnitString = "Brightness(SI lux)";
break;
case Sensor.TYPE_MAGNETIC_FIELD:
sensorUnitString = "Magnetic-field(uT)";
break;
case Sensor.TYPE_ORIENTATION:
sensorUnitString = "Angle(°)";
break;
case Sensor.TYPE_PRESSURE:
sensorUnitString = "Pressure(hPa)";
break;
case Sensor.TYPE_PROXIMITY:
sensorUnitString = "Distance(cm)";
break;
case Sensor.TYPE_TEMPERATURE:
sensorUnitString = "Temperature(℃)";
break;
case Sensor.TYPE_LINEAR_ACCELERATION:
sensorUnitString = "Linear-Acceleration(m/sec^2)";
break;
case Sensor.TYPE_GRAVITY:
sensorUnitString = "Gravity(m/sec^2)";
break;
case Sensor.TYPE_ROTATION_VECTOR:
sensorUnitString = "Rotation Vector";
break;
default:
sensorUnitString = sensor.getName();
break;
}
return sensorUnitString;
}
@Override
public void onSensorChanged(final SensorEvent event) {
Sensor sensor = event.sensor;
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
//
initialCordinate = endCordinate;
for (int a = 0; a < accelRaw.length; a++) {
accelRaw[a] = (double) event.values[a];
}
Accel = accelCorrection(accelRaw);
if (ifStatementSwitch == 1) {
System.arraycopy(accelRaw, 0, initAccel, 0, initAccel.length);
} else {
System.arraycopy(accelRaw, 0, endAccel, 0, endAccel.length);
}
ifStatementSwitch = ifStatementSwitch * -1;
for (int a = 0; a < cordinateChange.length; a++) {
cordinateChange[a] = endAccel[a] - initAccel[a];
}
cordinateChange[2] = cordinateChange[2] * 0.8;
endCordinate =
cordinateDetect(initialCordinate, accelRaw, (microSecondSensorDelay / (Math.pow(10, 6))));
// timer.scheduleAtFixedRate(new Delay(), 0, 1000);
// writeFile(String.format("%f,%f,%f%s", cordinateChange[0], cordinateChange[1],
// cordinateChange[2], System.getProperty("line.separator")));
rawAccelHandler.sendEmptyMessage(0);
accelValueHandlerTotal.sendEmptyMessage(0);
AccelValueHandler.sendEmptyMessage(0);
initialCoordinateHandler.sendEmptyMessage(0);
endCordinateHandler.sendEmptyMessage(0);
distanceHandler.sendEmptyMessage(0);
}
}
@Override
public void initRobot() {
hardwareMap.logDevices();
dashboard = HalDashboard.getInstance();
//
// Enumerates all Android sensors.
//
Context context = FtcOpMode.getInstance().hardwareMap.appContext;
SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
List<Sensor> sensorList = sensorManager.getSensorList(Sensor.TYPE_ALL);
dashboard.displayPrintf(0, "Android Sensors:");
int lineNum = 1;
for (Sensor sensor : sensorList) {
dashboard.displayPrintf(
lineNum,
"%02d->%s, %s, %d",
sensor.getType(),
sensor.getVendor(),
sensor.getName(),
sensor.getVersion());
lineNum++;
if (lineNum >= HalDashboard.MAX_NUM_TEXTLINES) {
break;
}
}
//
// Create Android sensors.
//
accel = FtcAndroidSensor.createInstance("accel", Sensor.TYPE_ACCELEROMETER, 3);
gravity = FtcAndroidSensor.createInstance("gravity", Sensor.TYPE_GRAVITY, 3);
gyro = FtcAndroidSensor.createInstance("gyro", Sensor.TYPE_GYROSCOPE, 3);
linearAccel =
FtcAndroidSensor.createInstance("linearAccel", Sensor.TYPE_LINEAR_ACCELERATION, 3);
rotation = FtcAndroidSensor.createInstance("rotation", Sensor.TYPE_ROTATION_VECTOR, 4);
magnetic = FtcAndroidSensor.createInstance("magnetic", Sensor.TYPE_MAGNETIC_FIELD, 3);
// orientation = FtcAndroidSensor.createInstance("orientation", Sensor.TYPE_ORIENTATION,
// 3);
proximity = FtcAndroidSensor.createInstance("proximity", Sensor.TYPE_PROXIMITY, 1);
light = FtcAndroidSensor.createInstance("light", Sensor.TYPE_LIGHT, 1);
} // initRobot
@SuppressWarnings("deprecation")
public static double getSensorChartMaxY(Sensor sensor) {
double yMax;
switch (sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
yMax = 20.0;
break;
case Sensor.TYPE_GYROSCOPE:
yMax = 40.0;
break;
case Sensor.TYPE_LIGHT:
yMax = 240.0;
break;
case Sensor.TYPE_MAGNETIC_FIELD:
yMax = 30.0;
break;
case Sensor.TYPE_ORIENTATION:
yMax = 150.0;
break;
case Sensor.TYPE_PROXIMITY:
yMax = 15.0;
break;
case Sensor.TYPE_TEMPERATURE:
yMax = 40.0;
break;
case Sensor.TYPE_LINEAR_ACCELERATION:
yMax = 30.0;
break;
case Sensor.TYPE_GRAVITY:
yMax = 10.0;
break;
case Sensor.TYPE_ROTATION_VECTOR:
yMax = 5.0;
break;
default:
yMax = 50.0;
break;
}
return yMax;
}
private int updateText() {
String s = mMsg.poll();
if (s == null) {
s = "";
List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
for (Sensor ss : sensors) {
s += "Sensor " + ss.getType() + " " + ss.getVendor() + " " + ss.getName() + "\n";
}
}
final String s2 = s;
runOnUiThread(
new Runnable() {
public void run() {
mText.setText(s2);
}
});
if (mMsg.size() > 15) return 20;
if (mMsg.size() > 8) return 100;
if (mMsg.size() > 4) return 500;
return 1000;
}
