public Quaternion(Reading.ReadingBase reader)
{
X = reader.ReadSingle("X");
Y = reader.ReadSingle("Y");
Z = reader.ReadSingle("Z");
W = reader.ReadSingle("W");
}
public MovementJump(Reading.ReadingBase reader)
{
velocity = reader.ReadSingle("MovementJump velocity");
sinAngle = reader.ReadSingle("MovementJump sinAngle");
cosAngle = reader.ReadSingle("MovementJump cosAngle");
xyspeed = reader.ReadSingle("MovementJump xyspeed");
}
public MovementFall(Reading.ReadingBase reader)
{
sinAngle = reader.ReadSingle("MovementFall sinAngle");
cosAngle = reader.ReadSingle("MovementFall cosAngle");
xyspeed = reader.ReadSingle("MovementFall xyspeed");
velocity = reader.ReadSingle("MovementFall velocity");
}
public Vector4(Reading.ReadingBase reader)
{
X = reader.ReadSingle("X");
Y = reader.ReadSingle("Y");
Z = reader.ReadSingle("Z");
O = reader.ReadSingle("O");
}
public ReadingRangeAggregate(
TimeRange timeStamp,
ReadingValuesRange ranges
)
: base(ranges)
{
TimeStamp = new TimeRange(timeStamp);
_min = _max = null;
}
private static Reading ToReading(double x, double y, double z)
{
var reading = new Reading
{
X = x,
Y = y,
Z = z,
};
return reading;
}
private static Reading ToReading(AccelerometerReading sensorReading)
{
var reading = new Reading
{
X = sensorReading.Acceleration.X,
Y = sensorReading.Acceleration.Y,
Z = sensorReading.Acceleration.Z,
};
return reading;
}
public ReadingRangeAggregate(
TimeRange timeStamp,
Range temperature,
Range humidity,
Range pressure,
Range windSpeed,
Range windDirection
)
: base(temperature, humidity, pressure, windSpeed, windDirection)
{
TimeStamp = new TimeRange(timeStamp);
_min = _max = null;
}
public override void AddActionPreferencesToList(ConsideredActions alreadyConsidered, IList<string> log)
{
var bestBook = Mage.GetBestBookToRead(_ability);
if (bestBook != null)
{
double gain = Mage.GetBookLevelGain(bestBook);
double effectiveDesire = _desireFunc(gain, ConditionDepth);
if (effectiveDesire > 0.01)
{
log.Add("Reading " + bestBook.Title + " worth " + (effectiveDesire).ToString("0.00"));
Reading readingAction = new Reading(bestBook, effectiveDesire);
alreadyConsidered.Add(readingAction);
}
}
}
public Reading GetRecord(int rec_number)
{
var resp = ReadNthReading(rec_number);
if (resp[1] != 0x06)
{
Console.WriteLine("Invalid number of records");
return null;
}
var date = BitConverter.ToInt32(resp, 2);
var glucose = BitConverter.ToInt32(resp, 6);
var dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
dtDateTime = dtDateTime.AddSeconds(date).ToLocalTime();
var rec = new Reading {Glucose = glucose, ReadingDate = dtDateTime};
Console.WriteLine("Read record {0} : {1}", rec_number, rec);
return rec;
}
public void AggregateMeanTest()
{
var start = new DateTime(2011, 6, 30, 22, 18, 58);
var values = new[] {
new ReadingValues(1.0, 2.0, Double.NaN,180, 4.0),
new ReadingValues(2.0, Double.NaN, Double.NaN,45, 6.0),
new ReadingValues(3.0, 4.0, Double.NaN,315, Double.NaN),
new ReadingValues(Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN)
};
var readings = new Reading[(values.Length*2)+2];
for(var i = 0; i < readings.Length; i++) {
readings[i] = new Reading(
start.Add(new TimeSpan(0,0,0,i)),
values[i % values.Length]
);
}
var means = Stats.StatsUtil.AggregateMean(readings, TimeUnit.Minute).ToArray();
Assert.That(means,Has.Length.EqualTo(2));
Assert.AreEqual(1.5, means[0].Temperature);
Assert.AreEqual(2, means[0].Pressure);
Assert.AreEqual(Double.NaN, means[0].Humidity);
Assert.AreEqual(
(values[0].WindDirection + values[1].WindDirection) / 2.0,
means[0].WindDirection, 0.000000000001
);
Assert.AreEqual(5, means[0].WindSpeed);
Assert.AreEqual(new DateTime(2011,6,30,22,18,0), means[0].BeginStamp);
Assert.AreEqual(new DateTime(2011,6,30,22,19,0), means[0].EndStamp);
Assert.AreEqual(2, means[1].Temperature);
Assert.AreEqual(3, means[1].Pressure);
Assert.AreEqual(Double.NaN, means[1].Humidity);
Assert.AreEqual(0, means[1].WindDirection, 0.000000000001);
Assert.AreEqual(5, means[1].WindSpeed);
Assert.AreEqual(new DateTime(2011, 6, 30, 22, 19, 0), means[1].BeginStamp);
Assert.AreEqual(new DateTime(2011, 6, 30, 22, 20, 0), means[1].EndStamp);
}
public static ReadingViewModel ToViewModel(this Reading reading)
{
var vm = new ReadingViewModel()
{
Id = reading.ReadingId,
ReadDate = reading.ReadDate,
TripId = reading.TripId,
Latitude = reading.Latitude,
Longitude = reading.Longitude,
AirIntakeTemperature = reading.AirIntakeTemperature,
AmbientAirTemperature = reading.AmbientAirTemperature,
EngineCoolantTemperature = reading.EngineCoolantTemperature,
OilTemperature = reading.OilTemperature,
EngineRpm = reading.EngineRpm,
Speed = reading.Speed,
MassAirFlow = reading.MassAirFlow,
ThrottlePosition = reading.ThrottlePosition,
FuelType = reading.FuelType,
FuelLevel = reading.FuelLevel
};
return(vm);
}
/// <summary>
/// Get a reading from the touch screen.
/// </summary>
/// <returns>A <see cref="Reading"/> with data about the touch status and coordinates</returns>
public Reading ReadTouch()
{
uint valueX;
uint valueY;
uint valueZ;
UInt32 rawValue;
Reading reading = new Reading();
byte[] buffer = new byte[1];
//Debug.WriteLine("Current FIFO " + FifoSize());
if (FifoSize() > 0)
{
// read X, Y & Z
buffer = new byte[4];
if (_touchController.WriteReadPartial(new byte[] { REGISTER_TSC_DATA_XYZ }, buffer).Status == I2cTransferStatus.FullTransfer)
{
rawValue = (((UInt32)buffer[0] << 24)) | ((UInt32)(buffer[1] << 16)) | ((UInt32)(buffer[2] << 8)) | ((UInt32)(buffer[3] << 0));
valueX = (rawValue >> 20) & 0x00000FFF;
valueY = (rawValue >> 8) & 0x00000FFF;
valueZ = rawValue & 0x000000FF;
reading = new Reading(valueX, valueY, valueZ);
}
}
//Debug.WriteLine("Current FIFO " + FifoSize());
// reset FIFO
//ResetFIFO();
//Debug.WriteLine("Current FIFO " + FifoSize());
return(reading);
}
public void TestHogOnAllData()
{
var testResultsPath = @"C:\Users\Serban\Pictures\LeafHogs\testData\zDataTestsPerformance.txt";
var confidencePath = @"C:\Users\Serban\Pictures\LeafHogs\testData\zDataTestsConfidence.txt";
for (int i = 0; i < 10; i++) // number of data sets
{
var path = @"C:\Users\Serban\Pictures\LeafHogs\testData\data" + i + ".txt";
var data = new Reading(path);
Link.RenewalFactor = 0;
Link.Step = 0.1;
var sut = new NeuralNet(2, 10, data.InputValues[0], data.ExpectedResults[0]);
var iterations = sut.TrainAdaptive(data.InputValues, data.ExpectedResults, -0.00005, 250000); //put iteration limit?
sut.PrintWeights(@"C:\Users\Serban\Pictures\LeafHogs\testData\trainedOnData" + i + ".txt", iterations);
var testDataPath = @"C:\Users\Serban\Pictures\LeafHogs\testData\test" + i + ".txt";
var testData = new Reading(testDataPath);
string results = (i + 1).ToString() + " ";
string confidence = (i + 1).ToString() + " ";
for (int testSet = 0; testSet < testData.InputValues.Count; testSet++)
{
sut.ChangeData(testData.InputValues[testSet], testData.ExpectedResults[testSet]);
results += sut.CalculatePerformance() + " ";
confidence += sut.CalculateConfidence() + " ";
}
results += Environment.NewLine;
confidence += Environment.NewLine;
File.AppendAllText(testResultsPath, results);
File.AppendAllText(confidencePath, confidence);
}
}
public Reading GetRecord(int n)
{
var high = (byte) (n/256);
var low = (byte) (n%256);
Console.WriteLine("Reading record {0} (1)...", n);
SendCommandFrame(0x25, low, high, 0, 0);
Console.WriteLine("Waiting for record (1)...");
var a = ReadCommandFrame();
Console.WriteLine("Reading record {0} (2)...", n);
SendCommandFrame(0x26, low, high, 0, 0);
Console.WriteLine("Waiting for record (2)...");
var b = ReadCommandFrame();
var h = a[3];
var mi = a[2];
var ymd = a[1]*256 + a[0];
var d = ymd & 0x1F;
var mo = (ymd & 0x1E0) >> 5;
var y = ((ymd & 0xFE00) >> 9) + 2000;
var recDate = new DateTime(y, mo, d, h, mi, 0);
var glucose = b[1]*256 + b[0];
var rec = new Reading {ReadingDate = recDate, Glucose = glucose};
Console.WriteLine("Reading: {0}", rec);
return rec;
}
public override Reading getReading()
{
if (WiseSite.och == null)
{
return(null);
}
Reading r = new Reading
{
stale = IsStale("CloudCover")
};
if (r.stale)
{
r.safe = false;
r.usable = false;
_status = "Stale data";
}
else
{
r.value = WiseSite.och.CloudCover;
if (_max == 0)
{
r.safe = r.value == 0.0;
}
else
{
r.safe = r.value <= _max;
}
r.usable = true;
_status = string.Format("Cloud cover {0:f1} (max: {1:f1})", r.value, _max);
}
return(r);
}
/// <summary>Constructs a new instance.</summary>
/// <param name="socketNumber">The socket that this module is plugged in to.</param>
public PulseOximeter(string ComId) {
this.IsProbeAttached = false;
this.LastReading = null;
//Socket socket = Socket.GetSocket(socketNumber, true, this, null);
serialPort = SerialDevice.FromId(ComId);
//this.serialPort = GTI.SerialFactory.Create(socket, 4800, GTI.SerialParity.Even, GTI.SerialStopBits.One, 8, GTI.HardwareFlowControl.NotRequired, this);
serialPort.BaudRate = 4800;
serialPort.Parity = SerialParity.Even;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
_outStream = serialPort.OutputStream;
_inStream = serialPort.InputStream;
SerialWriter = new DataWriter(_outStream);
SerialReader = new DataReader(_inStream);
//this.serialPort.ReadTimeout = new TimeSpan(0, 0, 0, 0, 500);
//this.serialPort.WriteTimeout = new TimeSpan(0, 0, 0, 0, 500);
//this.serialPort.Open();
this.workerThread = new Thread(this.DoWork);
this.workerThread.Start();
}
//------------------------------------------------------------------------------
uint ReadPayload(byte[] buffer, uint offset, uint numBytesAvailable)
{
uint numBytes = Math.Min(numBytesAvailable, mPayloadLen - mWritePosition);
if (IsMasked)
{
for (uint i = 0; i < numBytes; i++, mWritePosition++)
{
Payload[mWritePosition] = (byte)(buffer[offset++] ^ mMask[mWritePosition % 4]);
}
}
else
{
Array.Copy(buffer, offset, Payload, mWritePosition, numBytes);
mWritePosition += numBytes;
}
if (mWritePosition >= mPayloadLen)
{
mState = Reading.Complete;
}
return(numBytes);
}
protected void AddPossiblePlaceToTrip(Trip trip, Reading reading, TripPossiblePlaceType type)
{
var ownerId = trip.Car.OwnerId;
var possiblePlaces = _placeService.GetPlacesNearby(reading.Latitude,
reading.Longitude, 150, ownerId);
foreach (var place in possiblePlaces)
{
var possiblePlace = new TripPossiblePlace()
{
Trip = trip,
TripId = trip.TripId,
Place = place,
PlaceType = type,
Distance = Convert.ToDecimal(GeographyUtils.CalculateDistanceBetweenLocations(
reading.Latitude, reading.Longitude, place.Latitude, place.Longitude)),
Active = true
};
_tripPossiblePlaceService.Create(possiblePlace);
}
_logger.Debug($"Added possible {type.ToString()} to trip {trip.TripId}");
}
private void startTagSearch_Click(object sender, EventArgs e)
{
try
{
Vertex <ReadingTag> startTag = (Vertex <ReadingTag>)beginningTag.SelectedItem;
//mainGraph.TagFinder(startTag);
//createTagGraph(startTag.tagId);
List <WeightedEdge <ReadingTag> > list = mainGraph.TagFinder(startTag, new List <WeightedEdge <ReadingTag> >(), new List <Vertex <ReadingTag> >(), new List <Vertex <ReadingTag> >(), new List <WeightedEdge <ReadingTag> >());
Console.WriteLine(list.Count());
Console.WriteLine(list);
List <Reading> suggestedReadings = new List <Reading>();
string str = DatabaseInterface.databaseConnectionStr;
using (SqlConnection con = new SqlConnection(str))
{
foreach (WeightedEdge <ReadingTag> edge in list)
{
Console.WriteLine(edge.ToString());
foreach (int id in edge.ReadingIds)
{
Reading r = DatabaseInterface.getReadings(project.projectId, con, false, id).First();
if (r != null && suggestedReadings.Find(x => x.readingId == id) == null)
{
suggestedReadings.Add(r);
}
}
}
}
suggestedReadingsList.DataSource = suggestedReadings;
suggestedReadingsList.DisplayMember = "title";
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public void WorkInProgress(long current, long overall)
{
Reading?.Invoke(current, overall);
}
protected void HandleReading(Character character, ConsideredActions alreadyConsidered, IEnumerable<IBook> topicalBooks)
{
if (topicalBooks.Any())
{
var bestBook =
(from book in topicalBooks
orderby character.GetBookLevelGain(book),
book.Level ascending
select book).First();
double increase = character.GetBookLevelGain(bestBook);
double desire = CalculateDesire(increase) / (BaseTier + 1);
if (BaseDueDate != null)
{
desire /= (double)BaseDueDate;
}
Reading readingAction = new Reading(bestBook, desire);
alreadyConsidered.Add(readingAction);
}
}
public async Task <IHttpActionResult> PostReading(ReadingViewModel reading)
{
var currentEmployee = db.Users.Include(x => x.EmployeeDetails).FirstOrDefault(x => x.UserName == reading.UserName);
if (currentEmployee != null)
{
var readingModel = new Reading
{
Accuracy = reading.Accuracy,
Altitude = reading.Altitude,
AltitudeAccuracy = reading.AltitudeAccuracy,
MeterId = reading.MeterId,
DateCreated = DateTime.Now,
CreatedBy = currentEmployee.UserName,
EmployeeId = currentEmployee.EmployeeDetails.EmployeeId,
Speed = reading.Speed,
ReadingValue = reading.ReadingValue,
ReadingId = IdentityGenerator.NewSequentialGuid(),
Longitude = reading.Longitude,
Latitude = reading.Latitude,
Heading = reading.Heading,
LocationDateTime = DateTime.Now,
IsConfirmed = false,
};
//Fix Meter Issue
var previousReading = await db.Readings.Where(x => x.MeterId == reading.MeterId).OrderByDescending(x => x.DateCreated).FirstOrDefaultAsync();
if (previousReading != null)
{
if (readingModel.ReadingValue >= previousReading.ReadingValue)
{
readingModel.PreviousReading = previousReading;
}
else
{
return(Conflict());
}
}
try
{
db.Readings.Add(readingModel);
await db.SaveChangesAsync();
//Update ViewModel
reading.DateCreated = readingModel.DateCreated;
reading.ReadingId = readingModel.ReadingId;
reading.CreatedBy = readingModel.CreatedBy;
reading.EmployeeId = readingModel.EmployeeId;
return(CreatedAtRoute("DefaultApi", new { id = reading.ReadingId }, reading));
}
catch (DbUpdateException ex)
{
return(Conflict());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
return(NotFound());
}
public void UpdateLocation(Location location)
{
var locReading = new Reading<Location>(location);
distanceReadings.Add(locReading);
}
//call this function whenever saving a modified project file, saves everything within
public static Boolean updateProject(Project project)
{
int updatedReadings = 0;
int updatedWritings = 0;
foreach (Reading r in project.readings)
{
if (r.deleted)
{
deleteReading(r);
}
else if (r.readingId <= 0) //if true, reading is new
{
Reading tempReading = createReading(r.projectId, r.title, "", r.text, "", new DateTime(r.dateYear, getMonthNum(r.dateMonth), r.dateDay), r.publisherName, r.city, r.yearPublished);
r.readingId = tempReading.readingId;
}
else if (r.modified)
{
updateReading(r.readingId, r.title, r.text, "", new DateTime(r.dateYear, getMonthNum(r.dateMonth), r.dateDay), r.publisherName, "", r.yearPublished);
updatedReadings++;
}
//Authors
deleteAuthors(r.readingId);
foreach (Author author in r.authors)
{
Author tempAuthor = createAuthor(r.readingId, author.first, author.middle, author.last);
author.authorId = tempAuthor.authorId;
}
//ReadingTags
deleteReadingTagLinks(r.readingId);
foreach (ReadingTag tag in r.readingTags)
{
ReadingTag tempRTag = createReadingTag(r.readingId, tag.tag);
tag.tagId = tempRTag.tagId;
}
//Highlights and HighlightTags
foreach (Highlight highlight in r.highlights)
{
deleteHighlightTagLinks(highlight.highlightId);
}
deleteHighlights(r.readingId);
foreach (Highlight highlight in r.highlights)
{
Highlight tempHighlight = createHighlight(r.readingId, highlight.isQuote, highlight.charNum, highlight.charCount);
foreach (HighlightTag tag in highlight.highlightTags)
{
HighlightTag tempHTag = createHighlightTag(tempHighlight.highlightId, tag.tag);
tag.tagId = tempHTag.tagId;
}
highlight.highlightId = tempHighlight.highlightId;
}
r.modified = false;
}
for (int i = project.readings.Count - 1; i >= 0; i--) //loop through backwards and delete as encountered
{
if (project.readings.ElementAt(i).modified)
{
project.readings.RemoveAt(i);
}
}
foreach (Writing w in project.writings)
{
if (w.deleted)
{
deleteWriting(w);
}
else if (w.writingId <= 0)
{
Writing tempWriting = createWriting(w.projectId, w.text);
w.writingId = tempWriting.writingId;
}
else if (w.modified)
{
updateWriting(w);
updatedWritings++;
}
w.modified = false;
}
for (int i = project.writings.Count - 1; i >= 0; i--)
{
if (project.writings.ElementAt(i).modified)
{
project.writings.RemoveAt(i);
}
}
String message = "";
if (updatedReadings == 0 && updatedWritings != 0)
{
message = updatedWritings + " Writings Updated.";
}
else if (updatedWritings == 0 && updatedReadings != 0)
{
message = updatedReadings + " Readings Updated.";
}
else if (updatedWritings != 0 && updatedReadings != 0)
{
message = updatedReadings + " Readings Updated and " + updatedWritings + " Writings Updated.";
}
if (updatedWritings != 0 || updatedReadings != 0)
{
PopupForm popup = new PopupForm(message);
popup.Show();
}
return(true);
}
static void Main()
{
int num = 0;
do
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("-------------------------");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("1. Add a task");
Console.WriteLine("2. Remove a task");
Console.WriteLine("3. Mark a task complete");
Console.WriteLine("4. List tasks");
Console.WriteLine("5. EXIT");
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("-------------------------");
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write("What would you like to do? (Please enter the corresponding number): ");
Console.ResetColor();
num = Reading.ReadInt32FromConsole();
switch (num)
{
case -1:
Console.WriteLine("Please select a valid option. (1 through 5)");
break;
case 1:
Console.Write("Please enter a task: ");
var input = Reading.ReadTextLineFromConsole();
var ut = new UserTask(input);
tm.UserTasks.Add(ut);
Console.WriteLine($"New Task: {ut.ToString()}");
break;
case 2:
int i = 0;
int j = 1;
for (i = 0; i < tm.UserTasks.Count; i++)
{
Console.Write(j + " ");
Console.WriteLine(tm.UserTasks[i]);
j++;
}
Console.WriteLine();
Console.Write("Please write out the task you would like to remove (CASE-SENSITIVE [include (complete) if applicable]): ");
input = Reading.ReadTextLineFromConsole();
ut = new UserTask(input);
for (i = 0; i < tm.UserTasks.Count; i++)
{
if (input == tm.UserTasks[i].UserInput)
{
tm.UserTasks.RemoveAt(i);
break;
}
}
break;
case 3:
i = 0;
j = 1;
for (i = 0; i < tm.UserTasks.Count; i++)
{
Console.Write(j + " ");
Console.WriteLine(tm.UserTasks[i]);
j++;
}
Console.WriteLine();
Console.Write("Please write out the task you would like to mark complete (CASE-SENSITIVE): ");
input = Reading.ReadTextLineFromConsole();
ut = new UserTask(input);
for (i = 0; i < tm.UserTasks.Count; i++)
{
if (input == tm.UserTasks[i].UserInput)
{
tm.UserTasks[i].UserInput = tm.UserTasks[i].UserInput + " (complete)";
break;
}
}
break;
case 4:
i = 0;
j = 1;
for (i = 0; i < tm.UserTasks.Count; i++)
{
Console.Write(j + " ");
Console.WriteLine(tm.UserTasks[i]);
j++;
}
break;
case 5:
Environment.Exit(0);
break;
}
}while(num != 6);
}
public void Store(Reading Reading)
{
ListOfReadings.Add(Reading);
Update();
}
public WaterReservoirState(string id, int height, int alert, IEnumerable <SensorSpec> sensors, Reading current, Reading previous)
{
Height = height;
AlertHeight = alert;
Sensors = sensors;
Previous = previous;
Current = current;
ReservoirId = id;
}
public IEnumerable<Reading> ReadAll()
{
using(var cmd = _conn.CreateCommand()) {
cmd.CommandType = CommandType.Text;
cmd.CommandText = String.Format("SELECT * FROM {0}", CreateCsvTableName(_filePath));
using(var reader = cmd.ExecuteReader()) {
if (null == reader)
yield break;
while(reader.Read()) {
Reading reading;
try {
reading = new Reading(
AsDateTime(reader.GetValue(0)),
AsDouble(reader.GetValue(1)),
AsDouble(reader.GetValue(2)),
AsDouble(reader.GetValue(3)),
AsDouble(reader.GetValue(5)),
AsDouble(reader.GetValue(4))
);
}
catch(Exception ex) {
continue;
}
yield return reading;
}
}
}
}
public void Reading_RoundTripsCorrectly(Reading reading, string reason)
{
AssertObjectRoundTripsCorrectly(reading, reason);
}
private void DoWork()
{
bool sync = false;
byte[] data = new byte[5];
while (true)
{
int totalRead = 0;
if (!sync)
{
int b = this.serialPort.ReadByte();
if (b < 0)
{
Thread.Sleep(100);
continue;
}
if (((b >> 7) & 0x1) != 1)
{
continue;
}
data[0] = (byte)b;
totalRead = 1;
sync = true;
}
while (totalRead < 5)
{
int read = this.serialPort.Read(data, totalRead, 5 - totalRead);
if (read < 0)
{
this.DebugPrint("Serial error");
sync = false;
if (this.IsProbeAttached)
{
this.IsProbeAttached = false;
this.OnProbeDetached(this, null);
}
continue;
}
totalRead += read;
}
if (((data[0] >> 7) & 0x1) != 1)
{
this.DebugPrint("Lost sync");
sync = false;
if (this.IsProbeAttached)
{
this.IsProbeAttached = false;
this.OnProbeDetached(this, null);
}
continue;
}
bool probeAttached = ((data[2] >> 4) & 0x1) == 0;
if (!probeAttached && this.IsProbeAttached)
{
this.IsProbeAttached = false;
this.OnProbeDetached(this, null);
}
if (!probeAttached || ((data[0] >> 6) & 0x1) != 1)
{
continue;
}
int signalStrength = data[0] & 0xF;
int pulseRate = ((data[2] << 1) & 0x80) + (data[3] & 0x7F);
int spO2 = data[4] & 0x7F;
if (pulseRate == 255 || spO2 == 127)
{
continue;
}
this.LastReading = new Reading(pulseRate, spO2, signalStrength);
if (probeAttached && !this.IsProbeAttached)
{
this.IsProbeAttached = true;
this.OnProbeAttached(this, null);
}
this.OnHeartbeat(this, this.LastReading);
}
}
protected Trip ProcessTrip(Trip trip)
{
_logger.Debug($"Started processing trip {trip.TripId}");
var currentDistanceTraveled = trip.DistanceTraveled ?? 0;
if (trip.Status == TripStatus.Processed)
{
// Trip has already been processed. Clean up anything that was done previously
RemovePossiblePlacesFromTrip(trip);
}
var readings = _db.Readings.Where(x => x.TripId == trip.TripId)
.OrderBy(x => x.ReadDate)
.ToList();
if (readings.Any())
{
NormalizeStartEndLocations(readings);
double maxSpeed = 0;
double totalSpeed = 0;
double totalDistance = 0;
double maxEngineRpm = 0;
double totalEngineRpm = 0;
TimeSpan idleTime = new TimeSpan(); //ticks
Reading previousReading = null;
for (int i = 0; i < readings.Count; i++)
{
var reading = readings[i];
if (reading.Speed.HasValue && reading.Speed.Value > maxSpeed)
{
maxSpeed = reading.Speed.Value;
}
if (reading.EngineRpm.HasValue && reading.EngineRpm.Value > maxEngineRpm)
{
maxEngineRpm = reading.EngineRpm.Value;
}
totalSpeed += reading.Speed ?? 0;
totalEngineRpm += reading.EngineRpm ?? 0;
if (null != previousReading)
{
totalDistance += CalculateDistanceBetweenReadings(previousReading, reading);
if ((previousReading.Speed ?? 0) == 0 && (reading.Speed ?? 0) == 0)
{
idleTime = idleTime.Add(reading.ReadDate - previousReading.ReadDate);
}
}
previousReading = reading;
}
trip.AverageSpeed = totalSpeed / (readings.Count * 1.0);
trip.AverageEngineRpm = totalEngineRpm / (readings.Count * 1.0);
trip.MaxEngineRpm = maxEngineRpm;
trip.MaximumSpeed = maxSpeed;
trip.DistanceTraveled = totalDistance;
trip.IdleTime = Convert.ToInt64(idleTime.TotalMilliseconds);
//if the end date of the trip is null, set its end date to the read date of the
// last reading
if (!trip.EndDate.HasValue)
{
trip.EndDate = readings.Last().ReadDate;
}
var car = _db.Cars.FirstOrDefault(c => c.CarId == trip.CarId);
if (null != car &&
(!car.MileageLastUserSet.HasValue || car.MileageLastUserSet < trip.EndDate))
{
car.Mileage += trip.DistanceTraveled - currentDistanceTraveled;
}
_db.SaveChanges();
AddPossiblePlacesToTrip(trip, readings);
AddGuessedPlacesToTrip(trip);
}
trip.Status = TripStatus.Processed;
_db.SaveChanges();
_logger.Debug($"Finished processing trip {trip.TripId}");
return(trip);
}
public static Reading ToEntity(this ReadingModel model, Reading destination)
{
return(model.MapTo(destination));
}
public static void SplitHistogramsInSeparateFiles(string sourcePath, string destinationFolderPath)
{
var data = new Reading(sourcePath);
data.CreateTestData(destinationFolderPath);
}
public void ProcessHMIData(byte data)
{
Reading result = null;
if (data == '\r')
{
return;
}
if (data == '\n')
{
if (_parseState == 1)
{
string packet = Encoding.UTF8.GetString(_buffer, 0, _bufferLen);
//Console.WriteLine("Process Packet: [" + packet + "]");
float distance = 0.0f;
++TotalReadings;
++_readingCount;
if (float.TryParse(packet, NumberStyles.Any, CultureInfo.InvariantCulture, out distance))
{
result = new Reading(distance);
++_validReadingCount;
_averageReading += distance;
}
else
{
result = new Reading();
}
double time = (double)Stopwatch.GetTimestamp() / (double)Stopwatch.Frequency;
if (time - _updateTimer >= 1.0)
{
ReadingFrequency = _readingCount;
float avgDist = 0.0f;
if (_validReadingCount > 0)
{
avgDist = _averageReading / _validReadingCount;
}
_updateTimer = time;
_readingCount = 0;
_validReadingCount = 0;
_averageReading = 0.0f;
//Console.WriteLine("Hz: " + ReadingFrequency + "\t Distance: " + avgDist + "m");
}
}
_parseState = 1;
_bufferLen = 0;
}
else if (_parseState == 1)
{
if (_bufferLen == 32)
{
_parseState = 0;
_bufferLen = 0;
}
else if (data == '.' || (data >= '0' && data <= '9') || data == '.' || data == '-')
{
_buffer[_bufferLen++] = data;
}
}
if (ReceivedReading != null && result != null)
{
if (_uiInvokeControl != null)
{
_uiInvokeControl.Invoke((MethodInvoker) delegate
{
ReceivedReading(result);
});
}
else
{
ReceivedReading(result);
}
}
return;
}
public static Aqi CalculateAqi(Reading reading)
{
double[,,] breakpoints =
{
{
{ 0, 4.4 },
{ 4.5, 9.4 },
{ 9.5, 12.4 },
{ 12.5, 15.4 },
{ 15.5, 30.4 },
{ 30.5, 40.4 },
{ 40.5, 50.4 }
},
{
{ 0.000, 0.034 },
{ 0.035, 0.144 },
{ 0.145, 0.224 },
{ 0.225, 0.304 },
{ 0.305, 0.604 },
{ 0.605, 0.804 },
{ 0.805, 1.004 }
},
{
{ 0, 0.05 },
{ 0.08, 0.10 },
{ 0.15, 0.20 },
{ 0.25, 0.31 },
{ 0.65, 1.24 },
{ 1.25, 1.64 },
{ 1.65, 2.04 }
},
{
{ 0, 50 },
{ 51, 100 },
{ 101, 150 },
{ 151, 200 },
{ 201, 300 },
{ 301, 400 },
{ 401, 500 }
}
};
double i, c = 0, cLow = 0, cHigh = 0, iLow = 0, iHigh = 0;
Aqi aqi = new Aqi();
for (int x = 0; x < 4; x++)
{
switch (x)
{
case 0:
c = reading.Co;
break;
case 1:
c = reading.So;
break;
case 2:
c = reading.No;
break;
}
for (int y = 0; y < 7; y++)
{
if (c >= breakpoints[x, y, 0] && c <= breakpoints[x, y, 1])
{
cLow = breakpoints[x, y, 0];
cHigh = breakpoints[x, y, 1];
iLow = breakpoints[3, y, 0];
iHigh = breakpoints[3, y, 1];
break;
}
}
i = (iHigh - iLow) / (cHigh - cLow) * (c - cLow) + iLow;
if (i > aqi.Value)
{
aqi.Value = i;
switch (x)
{
case 0:
aqi.GasName = "CO";
break;
case 1:
aqi.GasName = "SO";
break;
case 2:
aqi.GasName = "NO";
break;
}
}
}
return(aqi);
}
private void AddReadingToActionList(IEnumerable<IBook> topicalBooks, Ability ability, ConsideredActions alreadyConsidered, IList<string> log)
{
IBook bestBook = Character.GetBestBookToRead(ability);
if (bestBook != null)
{
double gain = Character.GetBookLevelGain(bestBook);
double effectiveDesire = GetDesirabilityOfIncrease(gain);
if (!double.IsNaN(effectiveDesire) && effectiveDesire > 0)
{
log.Add("Reading " + bestBook.Title + " worth " + (effectiveDesire).ToString("0.00"));
Reading readingAction = new Reading(bestBook, effectiveDesire);
alreadyConsidered.Add(readingAction);
}
}
}
public void ReadObject_FromInt_OK()
{
var x = new Reading<int>(2);
var y = x.AsVariant<IReading<object>>();
((int) y.Get()).Should().Be.EqualTo(2);
}
public void InsertReading(Reading reading)
{
_readingDb.InsertActivity(reading);
}
private void FillCommandBuilder(SQLCommandBuilder builder, SqlCommand command, Reading obj)
{
if (builder == null || command == null || obj == null)
{
return;
}
builder.AddParameter(tableFieldNAME, "@p_name");
command.Parameters.AddWithValue("p_name", obj.Name);
builder.AddParameter(tableFieldID_BOOK, "@p_id_book");
{
object value = DBNull.Value;
if (obj.Book != null)
{
value = obj.Book.Id;
}
command.Parameters.AddWithValue("p_id_book", value);
}
builder.AddParameter(tableFieldNUMBER, "@p_number");
command.Parameters.AddWithValue("p_number", (object)obj.Number ?? DBNull.Value);
builder.AddParameter(tableFieldFIRSTPAGE, "@p_firstpage");
command.Parameters.AddWithValue("p_firstpage", (object)obj.FirstPage ?? DBNull.Value);
builder.AddParameter(tableFieldLASTPAGE, "@p_lastpage");
command.Parameters.AddWithValue("p_lastpage", (object)obj.LastPage ?? DBNull.Value);
builder.AddParameter(tableFieldRETELLING, "@p_retelling");
command.Parameters.AddWithValue("p_retelling", obj.Retelling);
builder.AddParameter(tableFieldSUMMARY, "@p_summary");
command.Parameters.AddWithValue("p_summary", obj.Summary);
builder.AddParameter(tableFieldHINT, "@p_hint");
command.Parameters.AddWithValue("p_hint", obj.Hint);
builder.AddParameter(tableFieldNOTE, "@p_note");
command.Parameters.AddWithValue("p_note", obj.Note);
}
/// <summary>
/// This override returns the Reading.
/// </summary>
/// <returns>This override returns the Reading.</returns>
public override string ToString()
{
return(Reading.ToString());
}
//
// The timer is enabled ONLY on non-Immediate sensors
//
private void onTimer(object StateObject)
{
if (!Enabled)
{
return;
}
DateTime now = DateTime.Now;
Reading currentReading = getReading();
if (currentReading == null)
{
return;
}
if (_readings == null)
{
_readings = new FixedSizedQueue <Reading>(_nreadings);
}
Reading[] arr = _readings.ToArray();
List <string> values = new List <string>();
int nbad = 0, nstale = 0, nreadings = 0;
foreach (Reading r in arr) // before current reading
{
values.Add(r.ToString());
nreadings++;
if (!r.safe)
{
nbad++;
}
if (r.stale)
{
nstale++;
}
}
SensorState savedState = _state;
bool wassafe = StateIsSet(SensorState.Safe);
bool wasready = StateIsSet(SensorState.EnoughReadings);
_readings.Enqueue(currentReading);
arr = _readings.ToArray();
values = new List <string>();
nbad = 0;
nstale = 0;
nreadings = 0;
foreach (Reading r in arr) // including current reading
{
values.Add(r.ToString());
nreadings++;
if (!r.safe)
{
nbad++;
}
if (r.stale)
{
nstale++;
}
}
debugger.WriteLine(Debugger.DebugLevel.DebugSafety,
"onTimer: Sensor ({0}) readings: [{1}]",
WiseName, String.Join(",", values));
_nreadings = nreadings;
_nbad = nbad;
_nstale = nstale;
lock (_lock)
{
UnsetState(SensorState.Safe);
if (HasAttribute(SensorAttribute.CanBeStale) && (_nstale > 0))
{
ExtendUnsafety(string.Format("{0} stale reading{1}", _nstale, _nstale > 1 ? "s" : ""));
SetState(SensorState.Stale);
return; // Remain unsafe - at least one stale reading
}
else
{
UnsetState(SensorState.Stale);
}
if (_readings.ToArray().Count() != _repeats)
{
UnsetState(SensorState.EnoughReadings);
return; // Remain unsafe - not enough readings
}
else
{
if (!StateIsSet(SensorState.EnoughReadings))
{
activityMonitor.Event(new Event.SafetyEvent(
sensor: WiseName,
details: "Became ready",
before: sensorState,
after: Event.SafetyEvent.SensorState.Ready));
sensorState = Event.SafetyEvent.SensorState.Ready;
}
SetState(SensorState.EnoughReadings);
}
if (_nbad == _repeats)
{
ExtendUnsafety("All readings are unsafe");
if (wasready && wassafe)
{
activityMonitor.Event(new Event.SafetyEvent(
sensor: WiseName,
details: "Became unsafe",
before: sensorState,
after: Event.SafetyEvent.SensorState.NotSafe));
}
sensorState = Event.SafetyEvent.SensorState.NotSafe;
return; // Remain unsafe - all readings are unsafe
}
bool prolong = true;
if (StateIsSet(SensorState.Stabilizing))
{
if (currentReading.stale || !currentReading.safe)
{
ExtendUnsafety("Unsafe reading while stabilizing");
return;
}
if (now.CompareTo(_endOfStabilization) <= 0)
{
return;
}
else
{
UnsetState(SensorState.Stabilizing);
prolong = false; // don't prolong if just ended stabilization
}
}
// If we got here the sensor is currently safe
if (wasready && StateIsSet(SensorState.EnoughReadings) && !wassafe && prolong)
{
ExtendUnsafety("Readings just turned safe");
return; // Remain unsafe - just begun stabilizing
}
SetState(SensorState.Safe);
if (wasready && !wassafe)
{
activityMonitor.Event(new Event.SafetyEvent(
sensor: WiseName,
details: "Became safe",
before: sensorState,
after: Event.SafetyEvent.SensorState.Safe));
}
sensorState = Event.SafetyEvent.SensorState.Safe;
}
}
public void Run()
{
PrintMenu();
while (true)
{
try {
var selectedMenu = Reading.ReadInt("Please enter number from menu");
switch (selectedMenu)
{
case 1:
EnterNewDoubleToConsole(ref _fieldOfDoubles, ref _position);
break;
case 2:
PrintNumbersFromField(_fieldOfDoubles);
break;
case 3:
try {
SortUtils.CocktailSortAscending(_fieldOfDoubles);
}
catch (Exception e) {
WriteLineColorRed(e.Message);
}
break;
case 4:
try {
SortUtils.CocktailSortDescending(_fieldOfDoubles);
}
catch (Exception e) {
WriteLineColorRed(e.Message);
}
break;
case 5:
FindMinInArrayAndPrintToConsole(_fieldOfDoubles);
break;
case 6:
FindFirstOccurenceOfNumberAndPrintToConsole(_fieldOfDoubles);
break;
case 7:
FindLastOccurenceOfNumberAndPrintToConsole(_fieldOfDoubles);
break;
case 8:
PrintMenu();
break;
case 9:
Console.WriteLine("Exiting!");
return;
default:
WriteLineColorRed("Unknown command!");
break;
}
}
catch (Exception e) {
WriteLineColorRed(e.Message);
}
}
}
public void ReadObject_FromString_OK()
{
var x = new Reading<string>("something");
var y = x.AsVariant<IReading<object>>();
y.Get().Should().Be.EqualTo("something");
}
public ReadingViewModel CreateFromExisting(Reading reading)
{
return(new ReadingViewModel(reading));
}
public Response Read(Reading reading)
{
bool tokenExist = AuthRepository.IsTokenExist(reading.AuthToken);
#if DEBUG
tokenExist = true;
#endif
if (tokenExist)
{
try
{
List<int> ridesIds = new List<int>();
var file = Convert.FromBase64String(reading.Content);//System.Text.Encoding.Unicode.GetBytes(reading.Content);
string fileName = DateTime.Now.ToString("yyyyMMddHHmmtt") + RandomString(5);
string tmpFilePath = Path.Combine(Path.GetTempPath(), fileName);
File.WriteAllBytes(tmpFilePath, file);
using (SQLiteConnection con = new SQLiteConnection("Data Source="+tmpFilePath))
{
con.Open();
string ride = "SELECT _id FROM ride";
using (SQLiteCommand cmd = new SQLiteCommand(ride, con))
{
using (SQLiteDataReader rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
ridesIds.Add(rdr.GetInt32(0));
}
}
}
using (PP_testEntities context = new PP_testEntities())
{
if (ridesIds.Count == 1)
{
var przejazd = new Przejazdy_fs();
przejazd.dane_przejazdu = file;
var userLogins = AuthRepository.GetLogin(reading.AuthToken);
#if DEBUG
var user = (from u in context.Uzytkownicies select u).FirstOrDefault();
#else
var user = (from u in context.Uzytkownicies where u.email == userLogins select u).FirstOrDefault();
#endif
przejazd.Uzytkownicy = user;
przejazd.id_przejazdu = Guid.NewGuid();
context.Przejazdy_fs.Add(przejazd);
AddTagsToRide(con, context, przejazd);
}
else if (ridesIds.Count > 1)
{
foreach (var id in ridesIds)
{
string fname = DateTime.Now.ToString("yyyyMMddHHmmtt") + RandomString(5);
string path = Path.Combine(Path.GetTempPath(), fname);
File.WriteAllBytes(path, file);
var przejazd = new Przejazdy_fs();
using (SQLiteConnection con2 = new SQLiteConnection("Data Source=" + path))
{
con2.Open();
string query = "DELETE FROM location_data where RIDE_ID <> " + id.ToString();
SQLiteCommand cmd = new SQLiteCommand(query, con2);
cmd.ExecuteNonQuery();
cmd.Dispose();
query = "DELETE FROM accelerometer_data where RIDE_ID <> " + id.ToString();
cmd = new SQLiteCommand(query, con2);
cmd.ExecuteNonQuery();
cmd.Dispose();
query = "DELETE FROM gyroscope_data where RIDE_ID <> " + id.ToString();
cmd = new SQLiteCommand(query, con2);
cmd.ExecuteNonQuery();
cmd.Dispose();
query = "DELETE FROM light_data where RIDE_ID <> " + id.ToString();
cmd = new SQLiteCommand(query, con2);
cmd.ExecuteNonQuery();
cmd.Dispose();
query = "DELETE FROM ride where _id <> " + id.ToString();
cmd = new SQLiteCommand(query, con2);
cmd.ExecuteNonQuery();
cmd.Dispose();
var userLogins = AuthRepository.GetLogin(reading.AuthToken);
#if DEBUG
var user = (from u in context.Uzytkownicies select u).FirstOrDefault();
#else
var user = (from u in context.Uzytkownicies where u.email == userLogins select u).FirstOrDefault();
#endif
przejazd.Uzytkownicy = user;
przejazd.id_przejazdu = Guid.NewGuid();
przejazd.dane_przejazdu = Encoding.ASCII.GetBytes(System.DateTime.Now.ToString());
context.Przejazdy_fs.Add(przejazd);
AddTagsToRide(con2, context, przejazd);
con2.Close();
GC.Collect();
GC.WaitForPendingFinalizers();
}
przejazd.dane_przejazdu = File.ReadAllBytes(path);
}
}
context.SaveChanges();
}
}
File.Delete(tmpFilePath);
return new Response() { Result = "OK" };
}
catch (Exception e)
{
return new Response() { Result = "Error", Reason = e.Message };
}
}
else
{
return new Response() {Result = "Error", Reason = "Zły token sesji"};
}
}
public HistoryReadingViewModel(Reading reading, HistorySearchResult parent)
{
databaseService = new DatabaseService();
this.parent = parent;
Reading = reading;
}
public Vector2(Reading.ReadingBase reader)
{
X = reader.ReadSingle("X");
Y = reader.ReadSingle("Y");
}
/// <summary>
/// Initialize the control
/// </summary>
/// <param name="readingText">The initial reading text. A format string with simple replacement fields.</param>
/// <param name="fieldReplacements">The replacements to show instead of the replacement fields. The replacement fields will show as locked portions in the text.</param>
/// <param name="predicateColor">The color for the normal editable text</param>
/// <param name="replacementColor">The color for the replacement fields</param>
public void Initialize(string readingText, string[] fieldReplacements, Color predicateColor, Color replacementColor)
{
StartInitialize();
// First, lets see how many valid fields we have. A valid field
// must be in range and must occur only once. If these conditions
// do not hold, then those format replacements fields are invalid and
// needs to be directly edited.
int replacementCount = fieldReplacements.Length;
int[] foundReplacements = new int[replacementCount];
int fieldCount = 0;
bool allFieldsVisited;
allFieldsVisited = Reading.VisitFields(
readingText,
delegate(int index)
{
if (index < replacementCount)
{
int currentCount = foundReplacements[index];
switch (currentCount)
{
case 0:
++fieldCount;
break;
case 1:
--fieldCount;
break;
}
foundReplacements[index] = currentCount + 1;
//Keep going
return(true);
}
else
{
return(false);
}
});
if (fieldCount != 0 && allFieldsVisited)
{
LockedField[] fields = new LockedField[fieldCount];
int offsetAdjustment = 0;
int currentField = 0;
string modifiedString =
Reading.ReplaceFields(
readingText,
delegate(int index, Match match)
{
Group fieldGroup = match.Groups[Reading.ReplaceFieldsMatchFieldGroupName];
if (index < replacementCount &&
foundReplacements[index] == 1)
{
string replacement = fieldReplacements[index];
int replacementLength = replacement.Length;
fields[currentField] = new LockedField(fieldGroup.Index + offsetAdjustment, replacementLength, fieldGroup.Value);
offsetAdjustment += replacementLength - fieldGroup.Length;
++currentField;
return(replacement);
}
return(null);
});
FinishInitialize(modifiedString, fields, predicateColor, replacementColor);
}
else
{
FinishInitialize(readingText, null, predicateColor, replacementColor);
}
}
