private void Accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs accel)
{
var action = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => UpdateUI(accel.Reading)));
//X is the left/right tilt, while Y is the fwd/rev tilt
double lr = accel.Reading.AccelerationX;
double fb = accel.Reading.AccelerationY;
handleTurn(lr);
handleDirection(fb);
}
private async void accelerometerSensor_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = args.Reading;
xAxis.Text = String.Format("{0,2:0.00}", reading.AccelerationX.ToString());
yAxis.Text = String.Format("{0,2:0.00}", reading.AccelerationY.ToString());
zAxis.Text = String.Format("{0,2:0.00}", reading.AccelerationZ.ToString());
});
}
private async void _accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
listXYZ.Add(new AccelXYZ()
{
X = args.Reading.AccelerationX, Y = args.Reading.AccelerationY, Z = args.Reading.AccelerationZ
});
//textBox.Text = string.Format("X: {0,5:0.00} Y: {1,5:0.00} Z: {2,5:0.00}", args.Reading.AccelerationX, args.Reading.AccelerationY, args.Reading.AccelerationZ);
});
}
/// <summary>
/// This is the event handler for acceleroemter ReadingChanged events.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
SampleCount++;
// Save the sample count if the foreground app is visible.
bool appVisible = (bool)ApplicationData.Current.LocalSettings.Values["IsAppVisible"];
if (appVisible)
{
ApplicationData.Current.LocalSettings.Values["SampleCount"] = SampleCount;
}
}
private void OnAccelerometerReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
accelerometerHistory.Items.Add(
string.Format("X:{0}, Y: {1}, Z:{2}"
, args.Reading.AccelerationX
, args.Reading.AccelerationY
, args.Reading.AccelerationZ)
);
});
}
void AccelerometerReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (SensorValueChanged != null)
{
SensorValueChanged(this, new SensorValueChangedEventArgs {
ValueType = MotionSensorValueType.Vector, SensorType = MotionSensorType.Accelerometer, Value = new MotionVector()
{
X = args.Reading.AccelerationX, Y = args.Reading.AccelerationY, Z = args.Reading.AccelerationZ
}
});
}
}
private static void AcclReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
readingAccl = e.Reading;
//GyrometerReading readingGyro = _gyrometer.GetCurrentReading();
//string timeStamp = nanoTime().ToString();
//writerCSV.WriteLine(timeStamp + ","
// + readingGyro.AngularVelocityX + "," + readingGyro.AngularVelocityY + "," + readingGyro.AngularVelocityZ
// + "," + readingAccl.AccelerationX + "," + readingAccl.AccelerationY + "," + readingAccl.AccelerationZ);
//writerCSV.WriteLine(timeStamp + ","
// + readingAccl.AccelerationX + "," + readingAccl.AccelerationY + "," + readingAccl.AccelerationZ);
}
private void Accelerometor_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (this.InvokeRequired)
{
this.Invoke((Action)(() => Accelerometor_ReadingChanged(sender, args)));
return;
}
lblXAccel.Text = $"{args.Reading.AccelerationX:0.00}";
lblYAccel.Text = $"{args.Reading.AccelerationY:0.00}";
lblZAccel.Text = $"{args.Reading.AccelerationZ:0.00}";
}
private async void ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = args.Reading;
int a = (int)((reading.AccelerationY * 100) + 117);
string accY = String.Format("{0,5:0.00}", a);
Debug.WriteLine(accY);
//System.Diagnostics.Debug.WriteLine("{0} {1} {2}", reading.AccelerationX, reading.AccelerationY, reading.AccelerationZ);
sendAsByte(a);
});
}
/// <summary>
/// Invoked when the device is moved
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void MyAccelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Get the current accelerometer reading
pitch = args.Reading.AccelerationY * 100;
roll = args.Reading.AccelerationX * 100;
// Calculate the spaceman trajectory
moveMrSpaceman();
});
}
private static void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
AccelerometerReading reading = e.Reading;
Vector3 accelerationAverage = new Vector3();
//newAcceration.X = (float)(reading.AccelerationX * AccelerometerAlpha + reading.AccelerationX * (1.0f - AccelerometerAlpha));// +0.20f;
//newAcceration.Y = (float)(reading.AccelerationY * AccelerometerAlpha + reading.AccelerationY * (1.0f - AccelerometerAlpha));
//newAcceration.Z = (float)(reading.AccelerationZ * AccelerometerAlpha + reading.AccelerationZ * (1.0f - AccelerometerAlpha));
if (LastAcceleromeratorValues.Count == 5)
{
LastAcceleromeratorValues.Dequeue();
}
LastAcceleromeratorValues.Enqueue(new Vector3((float)reading.AccelerationX, (float)reading.AccelerationY, (float)reading.AccelerationZ));
foreach (Vector3 val in LastAcceleromeratorValues.ToList())
{
accelerationAverage.X += val.X;
accelerationAverage.Y += val.Y;
accelerationAverage.Z += val.Z;
}
accelerationAverage.X /= 5;
accelerationAverage.Y /= 5;
accelerationAverage.Z /= 5;
Vector3 newAcceleration = new Vector3();
if (accelerationAverage.X > AccelerometerThreshold)
{
newAcceleration.X = (float)(CurrentAccelerometerValues.X + AccelerometerAlpha * (reading.AccelerationX - CurrentAccelerometerValues.X));
}
else
{
newAcceleration.X = accelerationAverage.X;
}
if (accelerationAverage.Y > AccelerometerThreshold)
{
newAcceleration.Y = (float)(CurrentAccelerometerValues.Y + AccelerometerAlpha * (reading.AccelerationY - CurrentAccelerometerValues.Y));
}
else
{
newAcceleration.Y = accelerationAverage.Y;
}
if (newAcceleration.Z > AccelerometerThreshold)
{
newAcceleration.Z = (float)(CurrentAccelerometerValues.Z + AccelerometerAlpha * (reading.AccelerationZ - CurrentAccelerometerValues.Z));
}
else
{
newAcceleration.Z = accelerationAverage.Z;
}
CurrentAccelerometerValues = newAcceleration;
}
//Событие изменения показаний акселерометра
async private void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
if (!m_isStarted)
{
return;
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Windows.Devices.Sensors.AccelerometerReading reading = e.Reading;
SendRollCommand(reading.AccelerationX, reading.AccelerationY, reading.AccelerationZ);
});
}
private void ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
AccelerometerReading reading = args.Reading;
Debug.WriteLine($"x={reading.AccelerationX,5:0.00}, y={reading.AccelerationY,5:0.00}, z={reading.AccelerationZ,5:0.00}");
count++;
if (count == 20)
{
// Stop reporting
accelerometer.ReportInterval = 0;
accelerometer.ReadingChanged -= new TypedEventHandler <Accelerometer, AccelerometerReadingChangedEventArgs>(ReadingChanged);
}
}
async private void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = e.Reading;
ScenarioOutput_X.Text = String.Format("{0,5:0.00}", reading.AccelerationX);
ScenarioOutput_Y.Text = String.Format("{0,5:0.00}", reading.AccelerationY);
ScenarioOutput_Z.Text = String.Format("{0,5:0.00}", reading.AccelerationZ);
});
_accelerometer.ReportInterval = 0;
_accelerometer.ReadingChanged -= new Windows.Foundation.TypedEventHandler <Windows.Devices.Sensors.Accelerometer, AccelerometerReadingChangedEventArgs>(ReadingChanged);
}
private void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
TestCount++;
AccelerometerReading reading = e.Reading;
string sMessage = "";
/*
* if (reading.AccelerationX > 0 && reading.AccelerationX < 0.1 && reading.AccelerationY > -0.02 && reading.AccelerationY < 0.05 && reading.AccelerationZ > -1.01 && reading.AccelerationZ < -0.93)
* {
* sMessage = "";
* sMessage += "Round" + TestRound + "->" + TestCount + ":";
* sMessage += string.Format(" Accelerometer X({0,5:0.00})", reading.AccelerationX);
* sMessage += string.Format(" Y({0,5:0.00})", reading.AccelerationY);
* sMessage += string.Format(" Z({0,5:0.00})", reading.AccelerationZ);
* sMessage += "\r\n";
*
* Alog.WriteText(sMessage);
*
* }
* else
* {
* sMessage = "";
* sMessage += "Round" + TestRound + "->" + TestCount + ":";
* sMessage += "Accelerometer Failed.";
* sMessage += "\r\n";
*
* Alog.WriteText(sMessage);
* }
*/
sMessage += "Round" + TestRound + "->" + TestCount + ":";
sMessage += string.Format(" Accelerometer X({0,5:0.00})", reading.AccelerationX);
sMessage += string.Format(" Y({0,5:0.00})", reading.AccelerationY);
sMessage += string.Format(" Z({0,5:0.00})", reading.AccelerationZ);
sMessage += "\r\n";
Alog.WriteText(sMessage);
_accelerometer.ReportInterval = 0;
_accelerometer.ReadingChanged -= new Windows.Foundation.TypedEventHandler <Windows.Devices.Sensors.Accelerometer, AccelerometerReadingChangedEventArgs>(ReadingChanged);
if (TestCount >= TestMaxCount)
{
Atimer.Cancel();
TestCount = 0;
Ftimer = ThreadPoolTimer.CreatePeriodicTimer(Flash_Timer_Tick, TimeSpan.FromMilliseconds(5000));
}
}
async private void ReadingChanged(object Accelerometer, AccelerometerReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = e.Reading;
var top = this.ViewModel.Player.Top;
var left = this.ViewModel.Player.Left;
var x = reading.AccelerationX;
var y = reading.AccelerationY;
var z = reading.AccelerationZ;
var pitchAngle = Math.Atan2(-x, Math.Sqrt(y *y + z *z)) * (180 / Math.PI); // formula calculating the angle on x
var rollAngle = Math.Atan2(y, z) * (180 / Math.PI); // formula calculating the angle on y
var speedY = 0.02;
var speedX = 0.05;
var newTop = this.ViewModel.Player.Top;
var newLeft = this.ViewModel.Player.Left;
if (rollAngle < -100)
{
newTop += speedY * (rollAngle - 90);
}
else if (rollAngle > -80)
{
newTop -= speedY * (rollAngle - 90);
}
if (pitchAngle > 20)
{
newLeft += speedX * (pitchAngle - 90);
}
else if (pitchAngle < -20)
{
newLeft -= speedX * (pitchAngle - 90);
}
// the following is to stop our object not to go outside of the canvas
if (newTop < this.HappyHttpCanvas.ActualHeight - 25 && newTop > 0)
{
this.ViewModel.Player.Top = newTop;
}
if (newLeft < this.HappyHttpCanvas.ActualWidth - 25 && newLeft > 0)
{
this.ViewModel.Player.Left = newLeft;
}
});
}
private void AccReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs e)
{
AccelerometerReading reading = e.Reading;
if (_sweeping && _capturingShot != null)
{
acceleroStatsList.Add(new DS4SavedItem.AccelerometerStats
{
accX = reading.AccelerationX,
accY = reading.AccelerationY,
accZ = reading.AccelerationZ,
timestamp = reading.Timestamp.UtcTicks
});
}
}
void accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (args == null)
{
return;
}
var reading = args.Reading;
accelerationValue.Y = reading.AccelerationY;
accelerationValue.X = reading.AccelerationX;
accelerationValue.Z = reading.AccelerationZ;
accelerationValue.TimeStamp = reading.Timestamp.Ticks;
}
void OnAccelerometerChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (!paused)
{
if (!startTime.HasValue)
{
startTime = args.Reading.Timestamp;
}
long t = (long)((args.Reading.Timestamp - startTime.Value).TotalMilliseconds);
double x = args.Reading.AccelerationX;
double y = args.Reading.AccelerationY;
double z = args.Reading.AccelerationZ + 1; // reverse gravity to make graph look balanced.
model.AddAccel(t, x, y, z);
}
}
private async void Accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (DateTime.Now.Subtract(lastUpdated).Milliseconds < TrackUpdateInterval || processing)
{
return;
}
lastUpdated = DateTime.Now;
processing = true;
double speed = (1.0 - args.Reading.AccelerationX);
var i = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// TODO: Add visualization
// Speed.Value = speed * Speed.Maximum;
});
// Scale number to 0 - .75;
double pwm = (speed * 0.75) * 255.0;
try
{
string s = "{\"PWM\": \"" + pwm.ToString("0") + "\"}\n";
using (StreamSocket clientSocket = new StreamSocket())
{
DataWriter writer = null;
await clientSocket.ConnectAsync(serverHost, portToUse());
using (writer = new DataWriter(clientSocket.OutputStream))
{
uint len = writer.WriteString(s);
await writer.StoreAsync();
await writer.FlushAsync();
}
}
}
catch (Exception e)
{
Debug.WriteLine(e);
}
processing = false;
}
async private void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = e.Reading;
double savetime0 = 0;
double nowtime = 0;
x = (float)reading.AccelerationX;
y = (float)reading.AccelerationY;
z = (float)reading.AccelerationZ;
if (!mInitialized)
{
x_old = x;
y_old = y;
z_old = z;
mInitialized = true;
savetime0 = nowtime;
}
else
{
double oldValue = ((x_old * x) + (y_old * y)) + (z_old *z);
double oldValueSqrT = Math.Abs(Math.Sqrt((double)(((x_old * x_old) + (y_old * y_old)) + (z_old * z_old))));
double newValue = Math.Abs(Math.Sqrt((double)(((x * x) + (y * y)) + (z * z))));
oldValue /= oldValueSqrT *newValue;
if ((oldValue <= 0.994) && (oldValue > 0.9))
{
if (!hasChanged)
{
hasChanged = true;
counter++; //here the counter
Lan.Text = String.Format("{0,5:####}", counter);
}
else
{
hasChanged = false;
}
}
x_old = x;
y_old = y;
z_old = z;
savetime0 = nowtime;
mInitialized = false;
///Rank
}
});
}
} // end setupAcelerometer
private async void _accel_ReadingChanged(Accelerometer sender,
AccelerometerReadingChangedEventArgs args)
{
// need to put some stuff on the screen
// just to see the values for now.
AccelerometerReading reading = args.Reading;
// update the UI with some information from reading
// this is on a background thread
// need a delegate function, using await/async
await Dispatcher.RunAsync(
Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
// lambda expression (anonymous function)
updateUIInformation(reading);
}
);
}
void accelerometer2_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
try
{
var x = args.Reading.AccelerationX;
var y = args.Reading.AccelerationY;
var z = args.Reading.AccelerationZ;
var length = Math.Sqrt(x * x + y * y + z * z);
if (length < 0.2f)
{
if (DateTime.Now - lastEvent > TimeSpan.FromSeconds(1))
{
lastEvent = DateTime.Now;
node.SetState(Helper.FallThing.Ports[0], "true");
}
}
}
catch (Exception ex) { }
}
private void accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
if (!isTiming)
{
return;
}
var elapsedTime = stopwatch.Elapsed;
var accelerometerDataPoint = new LapDataPointViewModel
{
ElapsedTime = elapsedTime,
AccelerationX = args.Reading.AccelerationX,
AccelerationY = args.Reading.AccelerationY,
AccelerationZ = args.Reading.AccelerationZ,
SectorNumber = currentSector != null ? currentSector.SectorNumber : 1,
Timestamp = args.Reading.Timestamp.ToLocalTime()
};
lapCoordinates.Add(accelerometerDataPoint);
}
private void OnPhoneAccelerometerReading(AccelerometerReadingChangedEventArgs args)
{
AccelerometerReading reading = args.Reading;
DateTimeOffset ts = reading.Timestamp;
EventItem accX = new EventItem {
Stream = StreamsEnum.PhoneAccelerometerX, Timestamp = ts, Value = reading.AccelerationX
};
EventItem accY = new EventItem {
Stream = StreamsEnum.PhoneAccelerometerY, Timestamp = ts, Value = reading.AccelerationY
};
EventItem accZ = new EventItem {
Stream = StreamsEnum.PhoneAccelerometerZ, Timestamp = ts, Value = reading.AccelerationZ
};
//IList<EventItem> events = new[] { accX };
IList <EventItem> events = new[] { accX, accY, accZ };
//Debug.WriteLine(DateTime.Now);
SendToQueue(events);
}
private void AcclReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
readingAccl = e.Reading;
//GyrometerReading readingGyro = _gyrometer.GetCurrentReading();
/*
* textBox1.Invoke((Action)delegate
* {
* textBox1.Clear();
* //textBox1.Text = Convert.ToString(_acclDesiredReportInterval);
* textBox1.Text = string.Format("Acceleration - x: {0}, y: {1}, z: {2}", readingAccl.AccelerationX, readingAccl.AccelerationY, readingAccl.AccelerationZ);
* textBox1.AppendText(Environment.NewLine);
* textBox1.AppendText(string.Format("Gyro - x: {0}, y: {1}, z: {2}", readingGyro.AngularVelocityX, readingGyro.AngularVelocityY, readingGyro.AngularVelocityY));
* });
*/
//string timeStamp = nanoTime().ToString();
//writerCSV.WriteLine(timeStamp + ","
// + readingGyro.AngularVelocityX + "," + readingGyro.AngularVelocityY + "," + readingGyro.AngularVelocityZ
// + "," + readingAccl.AccelerationX + "," + readingAccl.AccelerationY + "," + readingAccl.AccelerationZ);
}
private async void Sensor_ReadingChangedAsync(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
await Task.Run(() =>
{
StoreData.current_ValueX = args.Reading.AccelerationX;
StoreData.current_ValueY = args.Reading.AccelerationY;
StoreData.current_ValueZ = args.Reading.AccelerationZ;
});
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AxisX.Text = args.Reading.AccelerationX.ToString();
AxisY.Text = args.Reading.AccelerationY.ToString();
AxisZ.Text = args.Reading.AccelerationZ.ToString();
AddValues(ValueX, args.Reading.AccelerationX);
AddValues(ValueY, args.Reading.AccelerationY);
AddValues(ValueZ, args.Reading.AccelerationZ);
});
}
private async void _myAcc_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
// update the UI with the reading.
/*
* The () => {} construct is called a lambda expression
* This is an anonymous function that can be used to create delegate methods
* of passed as arguments or returned as the value of a function call.
* In this case, the Accelerometer thread is asking the UI thread
* to update some display information from the readings.
*/
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
// update the UI from here.
AccelerometerReading reading = args.Reading;
updateUI(reading);
}
);
}
/// <summary>
/// Compute the difference, in degrees, between the device's orientation and the up direction (against gravity).
/// We only take into account the X and Y dimensions, i.e. device screen is perpendicular to the ground.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void CalculateDeviceRotation(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
m_rotationAngle = Constants.UIAngleOffset -
Math.Atan2(args.Reading.AccelerationY, args.Reading.AccelerationX) * 180.0 / Math.PI;
// Ensure that the range of the value is within [0, 360).
if (m_rotationAngle >= 360)
{
m_rotationAngle -= 360;
}
// Update the UI with the new value.
await Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
deviceRotation.Text = Math.Floor(m_rotationAngle).ToString();
UpdateArrowForRotation();
});
}
//double Z = 0;
private async void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = e.Reading;
X = reading.AccelerationX;
Y = reading.AccelerationY;
//Z = reading.AccelerationZ;
if (X > maxX)
{
maxX = X;
}
else if (X < minX)
{
minX = X;
}
if (Y > maxY)
{
maxY = Y;
}
else if (Y < minY)
{
minY = Y;
}
//if (Z > maxZ)
// maxZ = Z;
//else if (Z < minZ)
// minZ = Z;
txtXAxis.Text = String.Format("{0,5:0.00}, {1,5:0.00}, {2,5:0.00}", X, minX, maxX);
txtYAxis.Text = String.Format("{0,5:0.00}, {1,5:0.00}, {2,5:0.00}", Y, minY, maxY);
//txtZAxis.Text = String.Format("{0,5:0.00}, {1,5:0.00}, {2,5:0.00}", Z, minZ, maxZ);
DrawDotByPosition((X + Y) / 2, Colors.Green);
//DrawDotByPosition(Y, Colors.Green);
//DrawDotByPosition(Z, Colors.Blue);
});
}
