public fmMain()
{
InitializeComponent();
DevFile = null;// new DeviceFile();
//ListEditor.DevFile = DevFile;
}
private void buttonExecute_Click(object sender, EventArgs e)
{
DeviceFile file = this.textBoxScript.Tag as DeviceFile;
if (file == null)
{
return;
}
buttonSave_Click(sender, e);
string filename = ConfigHelper.GetFullPath(file.Location);
ProcessControl pc = new ProcessControl();
bool res = pc.Execute(filename, "");
MessageBox.Show(res.ToString() + " " + pc.ExitCode);
//ProcessStartInfo pi = new ProcessStartInfo();
//pi.FileName = filename;
//pi.CreateNoWindow = false;
//pi.Arguments = " >> " + filename + ".log";
//Process p = Process.Start(pi);
//if (p != null)
//{
// p.Exited += new EventHandler(process_Exited);
// p.EnableRaisingEvents = true;
//}
//else
//{
// MessageBox.Show("Execute script failed.");
//}
}
private void Form1_Load(object sender, EventArgs e)
{
DevFile = new DeviceFile();
bool result = false;
result = DevFile.LoadFromFile("PK2DeviceFile.dat");
/*
* if (!result) result = DevFile.LoadFromFile("C:\\Program Files\\Microchip\\PICkit 2\\PK2DeviceFile.dat");
* if (!result) result = DevFile.LoadFromFile("C:\\Program Files\\Microchip\\PICkit 2 v2\\PK2DeviceFile.dat");
* if (!result) result = DevFile.LoadFromFile("C:\\Program Files (x86)\\Microchip\\PICkit 2\\PK2DeviceFile.dat");
* if (!result) result = DevFile.LoadFromFile("C:\\Program Files (x86)\\Microchip\\PICkit 2 v2\\PK2DeviceFile.dat");
*/
if (!result)
{
if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
result = DevFile.LoadFromFile(openFileDialog1.FileName);
}
}
if (result)
{
DeviceFileLoaded();
}
}
private void buttonFileAdd_Click(object sender, EventArgs e)
{
DeviceFile file = new DeviceFile();
_dirMgt.DeviceDirInfor.Files.Add(file);
RefreshFileList(file);
}
private bool ExecuteFile(GCInterface gcInterface, DeviceFileType type, bool wait)
{
switch (type)
{
case DeviceFileType.StartScript:
return(ServiceControl.SetServiceStatus(gcInterface.InterfaceName, AdapterStatus.Running));
case DeviceFileType.StopScript:
return(ServiceControl.SetServiceStatus(gcInterface.InterfaceName, AdapterStatus.Stopped));
}
// map type
DeviceFileType t = type;
if (type == DeviceFileType.InstallScript ||
type == DeviceFileType.UninstallScript)
{
t = DeviceFileType.ServiceAssembly;
}
// find script
DeviceFile file = gcInterface.Directory.Files.FindFirstFile(t);
if (file == null)
{
GCError.SetLastError("Cannot find file : " + t.ToString() + " in " + gcInterface.ToString());
return(false);
}
// find installer
DeviceFile installer = gcInterface.Directory.Files.FindFirstFile(DeviceFileType.Installer);
if (installer == null)
{
GCError.SetLastError("Cannot find installer in " + gcInterface.ToString());
return(false);
}
ProcessControl pc = new ProcessControl();
string exefilename = ConfigHelper.GetFullPath(gcInterface.FolderPath + "\\" + file.Location);
string installfilename = ConfigHelper.GetFullPath(gcInterface.FolderPath + "\\" + installer.Location);
switch (type)
{
case DeviceFileType.ConfigAssembly:
return(ProcessControl.ExecuteAssemblyDirectly(exefilename, AdapterConfigArgument.InIMWizard));
case DeviceFileType.MonitorAssembly:
return(ProcessControl.ExecuteAssemblyDirectly(exefilename, ""));
case DeviceFileType.InstallScript:
return(pc.ExecuteAssembly(installfilename, "\"" + exefilename + "\"", true));
case DeviceFileType.UninstallScript:
return(pc.ExecuteAssembly(installfilename, "-u \"" + exefilename + "\"", true));
}
return(false);
}
private void listBoxFile_SelectedIndexChanged(object sender, EventArgs e)
{
DeviceFile file = this.listBoxFile.SelectedItem as DeviceFile;
if (file != null)
{
this.propertyGridFile.SelectedObject = file;
}
}
private bool CallAdapterConfigProcess(GCInterface gcInterface, string arg)
{
if (gcInterface == null)
{
return(false);
}
if (_cfgP != null && !_cfgP.HasExited && waitEvent == null)
{
waitEvent = new ManualResetEvent(false);
waitEvent.Reset();
_cfgP.Kill();
waitEvent.WaitOne(20000, true);
}
DeviceFile file = null;
if (arg == null)
{
file = gcInterface.Directory.Files.FindFirstFile(DeviceFileType.MonitorAssembly);
arg = AdapterConfigArgument.InIM;
}
else
{
file = gcInterface.Directory.Files.FindFirstFile(DeviceFileType.ConfigAssembly);
}
if (file == null)
{
return(false);
}
string exefilename = ConfigHelper.GetFullPath(gcInterface.FolderPath + "\\" + file.Location);
if (!System.IO.File.Exists(exefilename))
{
Program.Log.Write("{Interface} cannot find file : " + exefilename);
return(false);
}
_gcInterface = gcInterface;
ProcessStartInfo pi = new ProcessStartInfo();
pi.WorkingDirectory = Path.GetDirectoryName(exefilename);
pi.Arguments = arg; // AdapterConfigArgument.InIM;
pi.FileName = exefilename;
Process p = Process.Start(pi);
p.Exited += new EventHandler(p_Exited);
p.EnableRaisingEvents = true;
_cfgP = p;
return(true);
}
private void buttonFileDelete_Click(object sender, EventArgs e)
{
DeviceFile file = this.listBoxFile.SelectedItem as DeviceFile;
if (file != null)
{
_dirMgt.DeviceDirInfor.Files.Remove(file);
}
RefreshFileList(null);
}
private void comboBoxType_SelectedIndexChanged(object sender, EventArgs e)
{
string strType = this.comboBoxType.Text;
if (strType == null || strType.Length < 1)
{
return;
}
DeviceFileType type = (DeviceFileType)Enum.Parse(typeof(DeviceFileType), this.comboBoxType.Text);
DeviceFile file = _dirMgt.DeviceDirInfor.Files.FindFirstFile(type);
string filename = null;
if (file != null)
{
filename = ConfigHelper.GetFullPath(file.Location);
if (!File.Exists(filename))
{
filename = null;
}
}
if (filename == null)
{
if (MessageBox.Show(this, "Cannot find " + type.ToString() + ". Do you want to create one?", "Warning",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
string fn = type.ToString() + ".bat";
string fname = ConfigHelper.GetFullPath(fn);
using (StreamWriter sw = File.CreateText(fname))
{
sw.WriteLine("REM " + type.ToString());
}
if (file == null)
{
file = new DeviceFile();
file.Backupable = true;
file.Location = fn;
file.Type = type;
_dirMgt.DeviceDirInfor.Files.Add(file);
if (!_dirMgt.SaveDeviceDir())
{
MessageBox.Show("Save DeviceDir file failed.");
return;
}
}
}
}
this.textBoxScript.Tag = file;
buttonLoad_Click(sender, e);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
DevFile = new DeviceFile();
if (DevFile.LoadFromFile(openFileDialog1.FileName))
{
DeviceFileLoaded();
}
}
}
private void RefreshFileList(DeviceFile file)
{
this.listBoxFile.Items.Clear();
foreach (DeviceFile f in _dirMgt.DeviceDirInfor.Files)
{
int index = this.listBoxFile.Items.Add(f);
if (file == f)
{
this.listBoxFile.SelectedIndex = index;
}
}
}
private string BuildMessage()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Device File: {DeviceFile.GetType().Name}");
sb.AppendLine();
sb.AppendLine($"Event ID: (0x{EventId:x8})");
sb.AppendLine("Guest Stack Trace:");
sb.AppendLine(Context.Thread.GetGuestStackTrace());
return(sb.ToString());
}
private static bool UpdateInterfaceScript(Hashtable paramTable, DeviceFile file, DeviceFileType type, bool essentialFile)
{
if (file == null)
{
if (essentialFile)
{
GCError.SetLastError("Cannot find script file of type: " + type.ToString());
return(false);
}
else
{
return(true);
}
}
string path = paramTable[IMParameter.InterfaceDirectory] as string;
string filename = path + "\\" + file.Location;
try
{
string str = "";
using (StreamReader sr = File.OpenText(filename))
{
str = sr.ReadToEnd();
}
foreach (DictionaryEntry de in paramTable)
{
string key = de.Key as string;
string value = de.Value as string;
str = str.Replace(key, value);
}
using (StreamWriter sw = File.CreateText(filename))
{
sw.Write(str);
}
return(true);
}
catch (Exception err)
{
GCError.SetLastError("Error when processing file: " + filename);
GCError.SetLastError(err);
return(false);
}
}
private static List <DeviceFile> FromGPXV1(XmlDocument document, decimal lapIntervalMeters)
{
var result = new List <DeviceFile>();
var baseFile = FromGPXV1_Base(document, lapIntervalMeters);
foreach (var activity in baseFile.Activities)
{
var attach = new DeviceFile {
Author = baseFile.Author.Clone()
};
result.Add(attach);
attach.Activities.Add(activity);
}
return(result);
}
private static List <DeviceFile> FromTcxV2(XmlDocument Doc)
{
var Res = new List <DeviceFile>();
var BaseFile = FromTcxV2_Base(Doc);
DeviceFile attach;
foreach (var Act in BaseFile.Activities)
{
attach = new DeviceFile {
Author = BaseFile.Author.Clone()
};
Res.Add(attach);
attach.Activities.Add(Act);
}
return(Res);
}
private void buttonSave_Click(object sender, EventArgs e)
{
DeviceFile file = this.textBoxScript.Tag as DeviceFile;
if (file == null)
{
return;
}
string filename = ConfigHelper.GetFullPath(file.Location);
using (StreamWriter sw = File.CreateText(filename))
{
string str = this.textBoxScript.Text;
sw.Write(str);
}
}
private string BuildMessage()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Device File: {DeviceFile.GetType().Name}");
sb.AppendLine();
sb.AppendLine($"Ioctl (0x{Command.RawValue:x8})");
sb.AppendLine($"\tNumber: 0x{Command.Number:x8}");
sb.AppendLine($"\tType: 0x{Command.Type:x8}");
sb.AppendLine($"\tSize: 0x{Command.Size:x8}");
sb.AppendLine($"\tDirection: {Command.DirectionValue}");
sb.AppendLine("Guest Stack Trace:");
sb.AppendLine(Context.Thread.GetGuestStackTrace());
return(sb.ToString());
}
private void buttonLoad_Click(object sender, EventArgs e)
{
DeviceFile file = this.textBoxScript.Tag as DeviceFile;
if (file == null)
{
return;
}
string filename = ConfigHelper.GetFullPath(file.Location);
using (StreamReader sr = File.OpenText(filename))
{
string str = sr.ReadToEnd();
this.textBoxScript.Text = str;
}
this.textBoxLocation.Text = filename;
}
public static DeviceFile.DevicePartParams NewPart24r2(DeviceFile DevFile, string basePartName, string partName, DeviceTemplate template)
{
DeviceFile.DevicePartParams newPart = DevFile.PartsList.First(p => p.PartName == basePartName);
// These can be easily found from the family programmer's manual
newPart.PartName = partName;
newPart.DeviceID = template.deviceId;
newPart.ProgramMem = template.family.programSize / 2 + 1; // Size of program FLASH. Not sure what units this is
newPart.ConfigAddr = template.family.configAddr * 2; // Address of the highest config register (ie. CONFIG4)
newPart.ConfigWords = 4; // Number of config registers
// Mask out unused bits.
// This can be found in the PIC datasheet. Reserved bits should be masked out.
// Configuration registers are in reverse order, ie. { CONFIG4, CONFIG3, CONFIG2, CONFIG1 }, with the CONFIG4 at the LOWEST address.
newPart.ConfigMasks = new ushort[8] {
0x0000, 0xFFFF, 0xFFF3, 0x7BFF, 0, 0, 0, 0
};
newPart.ConfigBlank = new ushort[8] {
0xFFFF, 0xFFFF, 0xFFF3, 0x7BFF, 0, 0, 0, 0
}; // Default configuration (Check the datasheet to see what the reserved bits should be set to)
//NOTE: Above only tested with PIC24FJ256DA206.
// Code-protect detection (only used in PicKit2 GUI?)
newPart.CPConfig = 4; // Which config contains the code-protect bits. This corresponds to CONFIG1
newPart.CPMask = 0x3000; // There are two CP-config bits, if either are 0 then CP is active.
// PIC Family
newPart.Family = DevFile.Families.First(f => f.FamilyName == "PIC24r2").FamilyID;
// Update scripts to PIC24r2
newPart.ChipEraseScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_ChpErase450ms.1").ScriptNumber;
newPart.ProgMemAddrSetScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_SetAddr.1").ScriptNumber;
newPart.ProgMemRdScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_ProgMemRd32.1").ScriptNumber;
newPart.ProgMemWrPrepScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_ProgMemWrPrep.1").ScriptNumber;
newPart.ProgMemWrScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_ProgMemWr64.1").ScriptNumber;
return(newPart);
}
/// <summary>
/// Note: when copying passive SQL interface, this is only a shadow copy, which results in a new NT service, new tables (always empty), new GC SP and the same inbound/outbound SPs.
/// </summary>
/// <param name="fromInterface"></param>
/// <param name="toInterfaceName"></param>
/// <param name="toInterfaceDescription"></param>
/// <returns></returns>
public GCInterface CopyInterface(GCInterface fromInterface, string toInterfaceName, string toInterfaceDescription)
{
try
{
GCError.ClearLastError();
if (fromInterface == null || string.IsNullOrEmpty(toInterfaceName))
{
return(null);
}
string fromFolder = ConfigHelper.GetFullPath(fromInterface.FolderPath);
if (!Directory.Exists(fromFolder))
{
return(null);
}
// copy files
string toPath = Path.Combine(InterfacesFolder, toInterfaceName);
string toFolder = ConfigHelper.GetFullPath(toPath);
if (!Directory.Exists(toFolder))
{
Directory.CreateDirectory(toFolder);
}
string sourceDirFile = Path.Combine(fromFolder, DeviceDirManager.IndexFileName);
string targetDirFile = Path.Combine(toFolder, DeviceDirManager.IndexFileName);
File.Copy(sourceDirFile, targetDirFile, true);
int index = 0;
NotifyStart(fromInterface.Directory.Files.Count + 2, 0, index++, "Copying files...");
foreach (DeviceFile df in fromInterface.Directory.Files)
{
string f = df.Location;
string sourceFile = ConfigHelper.GetFullPath(fromFolder, f);
string fn = ConfigHelper.GetRelativePath(fromFolder, sourceFile);
string targetFile = ConfigHelper.GetFullPath(toFolder, fn);
string path = Path.GetDirectoryName(targetFile);
if (!Directory.Exists(path))
{
if (Directory.CreateDirectory(path) == null)
{
GCError.SetLastError("Cannot create folder " + path);
NotifyComplete(false, "");
return(null);
}
}
File.Copy(sourceFile, targetFile, true);
NotifyGoing(index++, "Copying files...");
}
// Update device dir
GCInterface i = null;
DeviceDirManager mgr = new DeviceDirManager(targetDirFile);
if (mgr.LoadDeviceDir())
{
mgr.DeviceDirInfor.Header.ID = "0";
mgr.DeviceDirInfor.Header.Name = toInterfaceName;
mgr.DeviceDirInfor.Header.Description = toInterfaceDescription;
// update interface name and description
if (!mgr.SaveDeviceDir())
{
GCError.SetLastError(mgr.LastError);
return(null);
}
// copy object
i = new GCInterface();
i.Directory = mgr.DeviceDirInfor;
i.Device = new GCDevice(mgr.DeviceDirInfor, toPath);
i.Device.DeviceID = int.Parse(mgr.DeviceDirInfor.Header.RefDeviceID);
i.Device.DeviceName = mgr.DeviceDirInfor.Header.RefDeviceName;
i.InterfaceName = toInterfaceName;
i.FolderPath = toPath;
// AddInterfaceToDatabase & update interface ID to DeviceDir file.
if (!AddInterfaceToDatabase(i))
{
return(null);
}
NotifyGoing(index++, "Registering interface...");
// update service config
DeviceFile df = mgr.DeviceDirInfor.Files.FindFirstFile(DeviceFileType.ServiceConfig);
string fn = ConfigHelper.GetFullPath(toFolder, df.Location);
AdapterServiceCfgMgt mgt = new AdapterServiceCfgMgt(fn);
if (mgt.Load())
{
mgt.Config.ServiceName = toInterfaceName;
if (!mgt.Save())
{
GCError.SetLastError(mgt.LastError);
return(null);
}
}
else
{
GCError.SetLastError(mgt.LastError);
return(null);
}
}
else
{
GCError.SetLastError(mgr.LastError);
return(null);
}
NotifyComplete(true, "Copy interface completed.");
return(i);
}
catch (Exception err)
{
GCError.SetLastError(err);
NotifyComplete(false, "Copy interface failed.");
return(null);
}
}
private static DeviceFile FromTcxV2_Base(XmlDocument Doc)
{
var ns = new XmlNamespaceManager(Doc.NameTable);
ns.AddNamespace("tcd", "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2");
ns.AddNamespace("ae", "http://www.garmin.com/xmlschemas/ActivityExtension/v2");
XMLParserHelper.Manager = ns;
//var Activities = Doc.SelectNodes("/tcd:TrainingCenterDatabase/tcd:Activities/tcd:Activity", ns);
var Activities = Doc.GetElementsByTagName("Activity");
DeviceActivity CurrentActivity;
DeviceLap CurrentLap;
DevicePoint CurrentPoint;
DeviceCreator CurrentCreator;
DeviceAuthor CurrentAuthor;
XmlNode WorkNode;
XmlAttribute WorkAttr;
DateTime dtTryParse;
DateTimeOffset dtoTryParse;
DeviceFile File = new DeviceFile();
CurrentAuthor = new DeviceAuthor();
File.Author = CurrentAuthor;
string VMajor, VMinor, BMajor, BMinor;
CurrentAuthor.Name = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:Name");
CurrentAuthor.Language = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:LangID");
CurrentAuthor.PartNumber = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:PartNumber");
VMajor = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:Build/tcd:Version/tcd:VersionMajor", "0");
VMinor = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:Build/tcd:Version/tcd:VersionMinor", "0");
BMajor = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:Build/tcd:Version/tcd:BuildMajor", "0");
BMinor = XMLParserHelper.SelectSingleTextString(Doc, "/tcd:TrainingCenterDatabase/tcd:Author/tcd:Build/tcd:Version/tcd:BuildMinor", "0");
CurrentAuthor.Version = VMajor + "." + VMinor + "." + BMajor + "." + BMinor;
foreach (XmlNode Activity in Activities)
{
CurrentActivity = new DeviceActivity();
File.Activities.Add(CurrentActivity);
CurrentActivity.Id = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Id");
if (CurrentActivity.Id != null && DateTimeOffset.TryParse(CurrentActivity.Id, out dtoTryParse))
{
//dtoTryParse = FSSecurity.Current.ToUserTime(dtoTryParse);
dtTryParse = new DateTime(dtoTryParse.Year, dtoTryParse.Month, dtoTryParse.Day, dtoTryParse.Hour, dtoTryParse.Minute, dtoTryParse.Second);
CurrentActivity.ActivityTime = dtTryParse;
}
CurrentActivity.Sport = XMLParserHelper.SelectSingleAttributeString(Activity, "Sport", "Unknown");
CurrentCreator = new DeviceCreator();
CurrentActivity.Creator = CurrentCreator;
CurrentCreator.Name = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:Name");
CurrentCreator.UnitID = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:UnitId");
CurrentCreator.ProductID = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:ProductID");
VMajor = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:Version/tcd:VersionMajor", "0");
VMinor = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:Version/tcd:VersionMinor", "0");
BMajor = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:Version/tcd:BuildMajor", "0");
BMinor = XMLParserHelper.SelectSingleTextString(Activity, "tcd:Creator/tcd:Version/tcd:BuildMinor", "0");
CurrentCreator.Version = VMajor + "." + VMinor + "." + BMajor + "." + BMinor;
var CreatorName = CurrentCreator.Name ?? "";
var Laps = Activity.SelectNodes("tcd:Lap", ns);
var IsFirst = true;
foreach (XmlNode Lap in Laps)
{
var MyInt = XMLParserHelper.SelectSingleTextString(Lap, "tcd:Intensity", "");
// This is for trailing resting tomtom laps that have zero distance and time
if (MyInt.ToLower() == "resting" && CreatorName.ToLower().IndexOf("tomtom") >= 0)
{
continue;
}
if (IsFirst)
{
IsFirst = false;
var TestSeconds = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:TotalTimeSeconds", null);
var TestDist = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:DistanceMeters", null);
if (TestSeconds == 0 && TestDist == 0)
{
continue;
}
}
CurrentLap = new DeviceLap();
CurrentActivity.Laps.Add(CurrentLap);
WorkAttr = Lap.Attributes["StartTime"];
if (null != WorkAttr && null != CurrentActivity.ActivityTime && DateTimeOffset.TryParse(WorkAttr.Value, out dtoTryParse))
{
//dtoTryParse = FSSecurity.Current.ToUserTime(dtoTryParse);
dtTryParse = new DateTime(dtoTryParse.Year, dtoTryParse.Month, dtoTryParse.Day, dtoTryParse.Hour, dtoTryParse.Minute, dtoTryParse.Second);
CurrentLap.StartSeconds = (dtTryParse - (CurrentActivity.ActivityTime ?? DateTime.Now)).TotalSeconds;
}
CurrentLap.Time = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:TotalTimeSeconds", null);
CurrentLap.Distance = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:DistanceMeters", null);
CurrentLap.SpeedAvg = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:Extensions/ae:LX/ae:AvgSpeed", null);
CurrentLap.SpeedMax = XMLParserHelper.SelectSingleTextDecimal(Lap, "tcd:MaximumSpeed", null);
CurrentLap.Calories = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:Calories", null);
CurrentLap.RPMAvg = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:Cadence", null);
CurrentLap.RPMMax = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:Extensions/ae:LX/ae:MaxBikeCadence", null);
CurrentLap.HeartRateAvg = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:AverageHeartRateBpm/tcd:Value", null);
CurrentLap.HeartRateMax = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:MaximumHeartRateBpm/tcd:Value", null);
CurrentLap.WattsAvg = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:Extensions/ae:LX/ae:AvgWatts", null);
CurrentLap.WattsMax = XMLParserHelper.SelectSingleTextInt(Lap, "tcd:Extensions/ae:LX/ae:MaxWatts", null);
var TrackPoints = Lap.SelectNodes("tcd:Track/tcd:Trackpoint", ns);
DevicePoint LastTrackPoint = null;
foreach (XmlNode Point in TrackPoints)
{
CurrentPoint = new DevicePoint();
CurrentLap.Track.Add(CurrentPoint);
WorkNode = Point.SelectSingleNode("tcd:Time", ns);
if (null != WorkNode && null != CurrentActivity.ActivityTime && DateTimeOffset.TryParse(WorkNode.InnerText, out dtoTryParse))
{
//dtoTryParse = FSSecurity.Current.ToUserTime(dtoTryParse);
dtTryParse = new DateTime(dtoTryParse.Year, dtoTryParse.Month, dtoTryParse.Day, dtoTryParse.Hour, dtoTryParse.Minute, dtoTryParse.Second);
CurrentPoint.StartSeconds = (dtTryParse - (CurrentActivity.ActivityTime ?? DateTime.Now)).TotalSeconds;
}
CurrentPoint.Latitude = XMLParserHelper.SelectSingleTextDecimal(Point, "tcd:Position/tcd:LatitudeDegrees", null);
CurrentPoint.Longitude = XMLParserHelper.SelectSingleTextDecimal(Point, "tcd:Position/tcd:LongitudeDegrees", null);
CurrentPoint.Altitude = XMLParserHelper.SelectSingleTextDecimal(Point, "tcd:AltitudeMeters", null);
CurrentPoint.Distance = XMLParserHelper.SelectSingleTextDecimal(Point, "tcd:DistanceMeters", null);
CurrentPoint.HR = XMLParserHelper.SelectSingleTextInt(Point, "tcd:HeartRateBpm/tcd:Value", null);
CurrentPoint.RPM = XMLParserHelper.SelectSingleTextInt(Point, "tcd:Cadence", null);
CurrentPoint.CAD = XMLParserHelper.SelectSingleTextInt(Point, "tcd:Extensions/ae:TPX/ae:RunCadence", null);
if (CurrentPoint.CAD != null)
{
CurrentPoint.CAD = CurrentPoint.CAD.Value * 2;
}
CurrentPoint.Speed = XMLParserHelper.SelectSingleTextDecimal(Point, "tcd:Extensions/ae:TPX/ae:Speed", null);
CurrentPoint.Watts = XMLParserHelper.SelectSingleTextInt(Point, "tcd:Extensions/ae:TPX/ae:Watts", null);
if (LastTrackPoint != null && CurrentPoint.Speed == null && (CurrentPoint.Distance != null && CurrentPoint.StartSeconds != null) && (LastTrackPoint.Distance != null && LastTrackPoint.StartSeconds != null))
{
// Last Distance and Time vs Current Distance and Time ->
var SecondDelta = (decimal)(CurrentPoint.StartSeconds - LastTrackPoint.StartSeconds);
var DistanceDelta = CurrentPoint.Distance - LastTrackPoint.Distance;
if (SecondDelta == 0 || DistanceDelta == 0)
{
CurrentPoint.Speed = 0;
}
else
{
CurrentPoint.Speed = DistanceDelta / SecondDelta;
}
}
LastTrackPoint = CurrentPoint;
}
var CadencePoints = from x in CurrentLap.Track
where x.CAD != null
select x;
if (CadencePoints.Any())
{
var m = (from x in CadencePoints
select x.CAD).Max();
var a = (from x in CadencePoints
select x.CAD).Average();
CurrentLap.CADAvg = (int?)a;
CurrentLap.CADMax = (int?)m;
}
}
}
return(File);
}
public fmPartWizard(DeviceFile DevFile)
{
InitializeComponent();
this.DevFile = DevFile;
this.step = 1;
}
public async Task <DeviceFile> HandleMultipartRequest()
{
var deviceFile = new DeviceFile();
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
await section.Body.CopyToAsync(deviceFile.memoryStream);
deviceFile.memoryStream.Seek(0, SeekOrigin.Begin);
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
// Content-Disposition: form-data; name="key"
//
// value
// Do not limit the key name length here because the
// multipart headers length limit is already in effect.
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
var encoding = GetEncoding(section);
using (var streamReader = new StreamReader(
section.Body,
encoding,
detectEncodingFromByteOrderMarks: true,
bufferSize: 1024,
leaveOpen: true))
{
// The value length limit is enforced by MultipartBodyLengthLimit
var value = await streamReader.ReadToEndAsync();
if (String.Equals(value, "undefined", StringComparison.OrdinalIgnoreCase))
{
value = String.Empty;
}
deviceFile.formAccumulator.Append(key.Value, value);
if (deviceFile.formAccumulator.ValueCount > _defaultFormOptions.ValueCountLimit)
{
throw new InvalidDataException($"Form key count limit {_defaultFormOptions.ValueCountLimit} exceeded.");
}
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
return(deviceFile);
}
/// <summary>
/// Patches the device file to add new PIC24r2 scripts and support
/// for various devices. Note that "PIC24r2" is not an official name,
/// I made it to distinguish it from the regular PIC24 chips since they
/// seem to have changed stuff.
/// </summary>
/// <param name="DevFile">The device file to patch</param>
public static void PatchDeviceFile(DeviceFile DevFile)
{
//// 1. Duplicate 24F scripts and patch ////
// Skip the script patching if they've already been patched
if (DevFile.Scripts.Where(s => s.ScriptName.StartsWith("24r2_")).Count() == 0)
{
// Get the PIC24 scripts
var PIC24Scripts = DevFile.Scripts.Where(s => s.ScriptName.StartsWith("24_"));
var newScripts = new List <DeviceFile.DeviceScripts>();
ushort sidx = (ushort)DevFile.Scripts.Length;
foreach (var script in PIC24Scripts)
{
DeviceFile.DeviceScripts newScript = script;
// Rename and re-index
sidx++;
newScript.ScriptName = "24r2_" + newScript.ScriptName.Substring(3);
newScript.ScriptNumber = sidx;
newScript.Script = (ushort[])newScript.Script.Clone();
// Patch the opcodes:
// TBLPAG address has changed from 0x32 to 0x54
// eg. MOV W0, TBLPAG instruction has changed from 0x880190 to 0x8802A0
List <DeviceFile.Opcode> opcodes = newScript.ParseScript();
foreach (DeviceFile.Opcode opcode in opcodes)
{
if ((OPCODES)opcode.opcode == OPCODES._COREINST24)
{
uint operand = (uint)(((uint)opcode.data[0] << 16) | ((uint)opcode.data[1] << 8) | opcode.data[2]);
// MOV W0, TBLPAG
// 88 01 90 -> 99 02 A0
if (operand == 0x880190)
{
int idx = opcode.index;
newScript.Script[idx + 2] = (ushort)((newScript.Script[idx + 2] & 0xFF00) | 0x02);
newScript.Script[idx + 1] = (ushort)((newScript.Script[idx + 1] & 0xFF00) | 0xA0);
}
}
}
newScripts.Add(newScript);
}
// Update DeviceFile
DevFile.Scripts = DevFile.Scripts.Concat(newScripts).ToArray();
DevFile.Info.NumberScripts += newScripts.Count;
}
//// 2. Add new PIC24 family ////
if (DevFile.Families.Where(f => f.FamilyName == "PIC24r2").Count() == 0)
{
var PIC24Family = DevFile.Families.First(f => f.FamilyName == "PIC24");
DeviceFile.DeviceFamilyParams newFamily = PIC24Family;
newFamily.FamilyName = "PIC24r2";
newFamily.FamilyID = (ushort)DevFile.Families.Length;
newFamily.FamilyType = newFamily.FamilyID;
// Assign new scripts
newFamily.ProgEntryScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_ProgEntry.1").ScriptNumber;
newFamily.ReadDevIDScript = DevFile.Scripts.First(s => s.ScriptName == "24r2_RdDevID.1").ScriptNumber;
// Update DeviceFile
DevFile.Families = DevFile.Families.Concat(new DeviceFile.DeviceFamilyParams[1] {
newFamily
}).ToArray();
DevFile.Info.NumberFamilies++;
}
//// 3. Add new PIC24 chips ////
var newParts = new List <DeviceFile.DevicePartParams>();
foreach (var dev in devices)
{
// Make sure the chip doesn't already exist
if (DevFile.PartsList.Where(p => p.PartName == dev.partName).Count() == 0)
{
// Add a chip by template
newParts.Add(NewPart24r2(DevFile, basePart, dev.partName, dev));
}
}
DevFile.PartsList = DevFile.PartsList.Concat(newParts).ToArray();
DevFile.Info.NumberParts += newParts.Count;
}
private void propertyGridFile_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
{
DeviceFile file = this.propertyGridFile.SelectedObject as DeviceFile;
RefreshFileList(file);
}
private static DeviceFile FromGPXV1_Base(XmlDocument document, decimal lapIntervalMeters)
{
var nav = document.CreateNavigator();
nav.MoveToFollowing(XPathNodeType.Element);
if (nav == null)
{
throw new Exception("File Type Not Supported");
}
var namespaces = nav.GetNamespacesInScope(XmlNamespaceScope.Local);
if (namespaces == null || !namespaces.Keys.Any())
{
throw new Exception("File Type Not Supported");
}
var namespacePrefixes =
namespaces.Join(
ValidNamespaces,
o => o.Value.ToLower(),
i => i.Value.ToLower(),
(i, o) => new { Type = o.Key, Prefix = string.IsNullOrWhiteSpace(i.Key) ? "gpx" : i.Key, Url = o.Value })
.ToList();
var prefixGpx = namespacePrefixes.Single(x => x.Type == NamespaceType.GPX).Prefix;
var prefixTrackPointExt = namespacePrefixes.SingleOrDefault(x => x.Type == NamespaceType.TrackPointExtensions)?.Prefix;
var prefixCluetrustExt = namespacePrefixes.SingleOrDefault(x => x.Type == NamespaceType.CluetrustExtensions)?.Prefix;
var namespaceManager = new XmlNamespaceManager(document.NameTable);
namespacePrefixes.ForEach(x => namespaceManager.AddNamespace(x.Prefix, x.Url));
XMLParserHelper.Manager = namespaceManager;
var creator = new DeviceCreator
{
Name =
XMLParserHelper.SelectSingleAttributeString(
document.DocumentElement,
"creator"),
Version =
XMLParserHelper.SelectSingleAttributeString(
document.DocumentElement,
"version")
};
var author = new DeviceAuthor {
Name = creator.Name, Version = creator.Version
};
var file = new DeviceFile();
file.Author = author;
DateTimeOffset dtoFileTime;
DateTime? fileTime = null;
var fileTimeString = XMLParserHelper.SelectSingleTextString(document, $"/{prefixGpx}:gpx/{prefixGpx}:metadata/{prefixGpx}:time");
if (!string.IsNullOrWhiteSpace(fileTimeString) && DateTimeOffset.TryParse(fileTimeString, out dtoFileTime))
{
// TODO: dtoFileTime = FSSecurity.Current.ToUserTime(dtoFileTime);
fileTime = dtoFileTime.DateTime;
}
// Walk through all tracks and assign to Activities; usually just 1...
var activityNodes = document.GetElementsByTagName("trk");
foreach (XmlNode activityNode in activityNodes)
{
var activity = new DeviceActivity();
file.Activities.Add(activity);
activity.Id = XMLParserHelper.SelectSingleTextString(activityNode, $"{prefixGpx}:name");
activity.Creator = creator;
activity.Sport = XMLParserHelper.SelectSingleTextString(activityNode, $"{prefixGpx}:type", "Unknown");
activity.ActivityTime = fileTime;
// Parse entire list of track points...
var allTrackPoints = new List <DevicePoint>();
var trackPointNodes = activityNode.SelectNodes($"{prefixGpx}:trkseg/{prefixGpx}:trkpt", namespaceManager);
if (trackPointNodes != null)
{
DateTime?activityStartTimeUtc = null;
foreach (XmlNode trackPointNode in trackPointNodes)
{
var point = new DevicePoint();
var pointTimeUtc = XMLParserHelper.SelectSingleTextDateTime(trackPointNode, $"{prefixGpx}:time");
if (pointTimeUtc != null)
{
if (activityStartTimeUtc == null)
{
activityStartTimeUtc = pointTimeUtc;
point.StartSeconds = 0;
point.Distance = 0;
}
else
{
point.StartSeconds = (pointTimeUtc.Value - activityStartTimeUtc.Value.AddSeconds(1)).TotalSeconds;
}
}
// Parse latitude / longitude...
point.Latitude = XMLParserHelper.SelectSingleAttributeDecimal(trackPointNode, "lat");
point.Longitude = XMLParserHelper.SelectSingleAttributeDecimal(trackPointNode, "lon");
// Parse altitude...
point.Altitude = XMLParserHelper.SelectSingleTextDecimal(
trackPointNode,
$"{prefixGpx}:ele");
// Parse TrackPoint extension data...
if (prefixTrackPointExt != null)
{
// Parse heart rate...
point.HR = XMLParserHelper.SelectSingleTextInt(
trackPointNode,
$"{prefixGpx}:extensions/{prefixTrackPointExt}:TrackPointExtension/{prefixTrackPointExt}:hr");
// Parse ambient temp...
point.Temp = XMLParserHelper.SelectSingleTextInt(
trackPointNode,
$"{prefixGpx}:extensions/{prefixTrackPointExt}:TrackPointExtension/{prefixTrackPointExt}:atemp");
// Parse cadence...
point.CAD = XMLParserHelper.SelectSingleTextInt(
trackPointNode,
$"{prefixGpx}:extensions/{prefixTrackPointExt}:TrackPointExtension/{prefixTrackPointExt}:cad");
}
// Parse Cluetrust extension data...
if (prefixCluetrustExt != null)
{
// Parse heart rate...
if (point.HR == null)
{
point.HR = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixCluetrustExt}:hr");
}
// Parse ambient temp...
if (point.Temp == null)
{
point.Temp = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixCluetrustExt}:temp");
}
// Parse cadence...
if (point.CAD == null)
{
point.CAD = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixCluetrustExt}:cadence");
}
}
// Parse any generic extensions data...
// Parse heart rate...
if (point.HR == null)
{
point.HR = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixGpx}:heartrate");
}
// Parse cadence...
if (point.CAD == null)
{
point.CAD = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixGpx}:cadence");
}
// Parse distance...
if (point.Distance == null)
{
point.Distance = XMLParserHelper.SelectSingleTextDecimal(trackPointNode, $"{prefixGpx}:extensions/{prefixGpx}:distance");
}
// Parse power...
if (point.Watts == null)
{
point.Watts = XMLParserHelper.SelectSingleTextInt(trackPointNode, $"{prefixGpx}:extensions/{prefixGpx}:power");
}
// Multiply CAD result x 2 like in TCX?
// TODO: Bike no...Run yes?
if (point.CAD != null)
{
point.CAD = point.CAD * 2;
}
allTrackPoints.Add(point);
}
}
// Re-run through point list to calculate distances and break up into laps...
var pointsHaveTimeInfo = allTrackPoints.All(p => p.StartSeconds.HasValue);
var lapList = new List <DeviceLap>();
var currentLap = new DeviceLap {
StartSeconds = pointsHaveTimeInfo ? (double?)0 : null
};
for (var i = 1; i < allTrackPoints.Count; i++)
{
var currentPoint = allTrackPoints[i];
var previousPoint = allTrackPoints[i - 1];
if (currentLap.Track.Count == 0)
{
var previousLap = activity.Laps.LastOrDefault();
if (previousLap != null && pointsHaveTimeInfo)
{
previousLap.Time = (decimal)(currentPoint.StartSeconds.Value - previousLap.StartSeconds.Value);
}
activity.Laps.Add(currentLap);
}
decimal?currentPointDistanceDelta = null;
if (currentPoint.Distance == null)
{
if (currentPoint.Latitude == null ||
currentPoint.Longitude == null ||
previousPoint.Latitude == null ||
previousPoint.Longitude == null)
{
continue;
}
var distanceKm = HaversineInKM(
(double)previousPoint.Latitude.Value,
(double)previousPoint.Longitude.Value,
(double)currentPoint.Latitude.Value,
(double)currentPoint.Longitude.Value);
currentPointDistanceDelta = (decimal)(distanceKm * 1000.0);
currentPoint.Distance = currentPointDistanceDelta + (previousPoint.Distance ?? 0);
}
if (i == 1)
{
previousPoint.Distance = previousPoint.Distance ?? 0;
currentLap.Track.Add(previousPoint);
}
currentLap.Track.Add(currentPoint);
if (pointsHaveTimeInfo)
{
var startSecondsDelta = (decimal)(currentPoint.StartSeconds.Value - previousPoint.StartSeconds.Value);
startSecondsDelta = startSecondsDelta == 0 ? 1 : startSecondsDelta;
currentPointDistanceDelta = currentPointDistanceDelta ?? currentPoint.Distance - previousPoint.Distance;
currentPoint.Speed = currentPointDistanceDelta / startSecondsDelta;
if (currentLap.StartSeconds == null)
{
currentLap.StartSeconds = currentPoint.StartSeconds;
}
}
currentLap.Distance = currentLap.Track.Last().Distance.Value - currentLap.Track.First().Distance.Value;
if (currentLap.Distance.Value < lapIntervalMeters)
{
continue;
}
// Reached the end of the lap, start a new one...
currentLap = new DeviceLap {
StartSeconds = currentLap.Track.Last().StartSeconds
};
}
// Calculate Time for last lap...
var lastLap = activity.Laps.Last();
if (pointsHaveTimeInfo)
{
lastLap.Time = (decimal)(lastLap.Track.Last().StartSeconds.Value - lastLap.Track.First().StartSeconds.Value);
}
// Loop through resulting laps to calculate Time and remaining aggregates...
activity.Laps.ForEach(lap =>
{
// Calculate HRMax and HRAvg from lap's collection of HR points...
var hrPoints = lap.Track.Where(t => t.HR != null).Select(x => x.HR.Value).ToList();
lap.HeartRateMax = hrPoints.Any() ? (int?)hrPoints.Max() : null;
lap.HeartRateAvg = hrPoints.Any() ? (int?)hrPoints.Average() : null;
// Calculate CADMax and CADAvg from lap's collection of CAD points...
var cadPoints = lap.Track.Where(t => t.CAD != null).Select(x => x.CAD.Value).ToList();
lap.CADMax = cadPoints.Any() ? (int?)cadPoints.Max() : null;
lap.CADAvg = cadPoints.Any() ? (int?)cadPoints.Average() : null;
// Calculate TempMax and TempAvg from lap's collection of Temp points...
var tempPoints = lap.Track.Where(t => t.Temp != null).Select(x => x.Temp.Value).ToList();
lap.TempMax = tempPoints.Any() ? (int?)tempPoints.Max() : null;
lap.TempAvg = tempPoints.Any() ? (int?)tempPoints.Average() : null;
// Calculage SpeedMax and SpeedAvg from lap's collection of points...
var speedPoints = lap.Track.Where(t => t.Speed != null).Select(x => x.Speed.Value).ToList();
lap.SpeedMax = speedPoints.Any() ? (decimal?)speedPoints.Max() : null;
lap.SpeedAvg = speedPoints.Any() ? (decimal?)speedPoints.Average() : null;
});
}
return(file);
}
static void Main(string[] args)
{
const string outputDir = @"..\..\..\Output";
decimal lapIntervalMeters = 1000;
var gpxFiles = new List <string>
{
@"..\..\..\GPXFiles\activity_1358503471.gpx",
@"..\..\..\GPXFiles\Morning_Ride.gpx",
@"..\..\..\GPXFiles\Evening_Run.gpx",
@"..\..\..\GPXFiles\Morning_Run.gpx",
@"..\..\..\GPXFiles\Cone Peak.gpx"
};
var serializer = new XmlSerializer(typeof(DeviceFile));
var deviceFiles = gpxFiles.ToDictionary(f => Path.GetFileNameWithoutExtension(f), f => DeviceFile.FromGpx(f, lapIntervalMeters));
deviceFiles.Keys.ToList().ForEach(k =>
{
var first = true;
var idx = 2;
deviceFiles[k].ToList().ForEach(file =>
{
var filenameSuffix = first ? string.Empty : (idx++).ToString();
var outputFile = Path.Combine(outputDir, $"{k}{filenameSuffix}.xml");
using (TextWriter writer = new StreamWriter(outputFile))
{
serializer.Serialize(writer, file);
}
first = false;
});
});
Console.WriteLine("\n\nPress any key to continue...");
Console.ReadKey();
}
