/// <summary>
/// Generates a serial number for the given model.
/// </summary>
public static ISerialNumber GenerateSerialNumber(this EDeviceModel model)
{
var date = DateTime.Now;
var code = "";
switch (model)
{
case EDeviceModel.P300: code = "P3"; break;
case EDeviceModel.P500: code = "P5"; break;
case EDeviceModel.P800: code = "P8"; break;
case EDeviceModel.PT500: code = "S5"; break;
case EDeviceModel.PT800: code = "S8"; break;
case EDeviceModel.AV760: code = "V7"; break;
default:
throw new Exception(model + " is not implemented for random serial number. Please implement it...");
}
var str = code + ('A' + date.Month) + (date.Year - 2000).ToString("00") + (++SERIAL_NUMBER_COUNTER).ToString("000");
return(ParseSerialNumber(str));
}
public static string GetUnlocalizedPartNumber(this EDeviceModel deviceModel)
{
switch (deviceModel)
{
case EDeviceModel.Internal: return("Internal");
case EDeviceModel.P300: return("P300");
case EDeviceModel.P500: return("P500");
case EDeviceModel.P800: return("P800");
case EDeviceModel.PT300: return("PT300");
case EDeviceModel.PT500: return("PT500");
case EDeviceModel.PT800: return("PT800");
case EDeviceModel.AV760: return("AV760");
case EDeviceModel._3XTM: return("T3");
case EDeviceModel._1XTM: return("T1");
case EDeviceModel.HT: return("HT");
case EDeviceModel.WL: return("WL");
default: {
throw new ArgumentException("Cannot get model code: unrecoginized device model " + deviceModel);
}
}
}
/// <summary>
/// Queries the Android drawable resource icon for the given gauge type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static int GetGaugeIcon(EDeviceModel type)
{
switch (type)
{
case EDeviceModel.P300:
return(Resource.Drawable.ic_render_gaugep300);
case EDeviceModel.P500:
return(Resource.Drawable.ic_render_gaugep500);
case EDeviceModel.P800:
return(Resource.Drawable.ic_render_gaugep800);
case EDeviceModel.AV760:
return(Resource.Drawable.ic_render_gaugeav760);
case EDeviceModel.PT500:
return(Resource.Drawable.ic_render_gaugept500);
case EDeviceModel.PT800:
return(Resource.Drawable.ic_render_gaugept800);
default:
return(Resource.Drawable.ic_logo_appiondefault);
}
}
/// <summary>
/// Returns the default protocol for the given version number. This is only used on the older, second, thrid and
/// forth gen devices.
/// </summary>
/// <returns>The protocol from device model.</returns>
/// <param name="dm">Dm.</param>
private EProtocolVersion FindProtocolFromDeviceModel(EDeviceModel dm)
{
switch (dm)
{
case EDeviceModel._1XTM:
case EDeviceModel._3XTM:
return(EProtocolVersion.V4);
case EDeviceModel.AV760:
return(EProtocolVersion.V1);
case EDeviceModel.HT:
return(EProtocolVersion.V4);
case EDeviceModel.P300:
case EDeviceModel.P500:
case EDeviceModel.P800:
return(EProtocolVersion.V1);
case EDeviceModel.PT300:
case EDeviceModel.PT500:
case EDeviceModel.PT800:
case EDeviceModel.WL:
return(EProtocolVersion.V4);
default:
return(EProtocolVersion.V1);
}
}
/// <summary>
/// Queries the Android string resource name for the given gauge.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static string GetTypeString(this EDeviceModel type)
{
var ion = (BaseAndroidION)AppState.context;
switch (type)
{
case EDeviceModel.P300:
return(ion.context.GetString(Resource.String.device_p300));
case EDeviceModel.P500:
return(ion.context.GetString(Resource.String.device_p500));
case EDeviceModel.P800:
return(ion.context.GetString(Resource.String.device_p800));
case EDeviceModel.AV760:
return(ion.context.GetString(Resource.String.device_av760));
case EDeviceModel.PT300:
return(ion.context.GetString(Resource.String.device_pt300));
case EDeviceModel.PT500:
return(ion.context.GetString(Resource.String.device_pt500));
case EDeviceModel.PT800:
return(ion.context.GetString(Resource.String.device_pt800));
case EDeviceModel.WL:
return(ion.context.GetString(Resource.String.device_wllibra));
default:
return(ion.context.GetString(Resource.String.device_unknown));
}
}
public TestParameters(EDeviceModel deviceModel, ESensorType sensorType, List <TargetPoint> targetPoints, HashSet <Grade> grades)
{
this.deviceModel = deviceModel;
this.sensorType = sensorType;
this.targetPoints = new List <TargetPoint>();
this.grades = grades;
this.targetPoints.AddRange(targetPoints);
targetPoints.Sort();
targetPoints.Reverse();
if (grades == null || grades.Count <= 0)
{
this.grades = new HashSet <Grade>();
this.grades.Add(new Grade(1.00, "F", false));
}
errorBand = 1;
foreach (var grade in grades)
{
if (grade.errorBand < errorBand)
{
errorBand = grade.errorBand;
}
}
}
/// <summary>
/// Constructs a UIImage for the given device model. By default the
/// method will cache the UIImage as to not rape the HDD, however,
/// you can opt out if you are a crazy person.
/// </summary>
/// <returns>The user interface image from device model.</returns>
/// <param name="deviceModel">Device model.</param>
public static UIImage GetUIImageFromDeviceModel(this EDeviceModel deviceModel, bool enforeCaching = true)
{
switch (deviceModel)
{
case EDeviceModel.P300:
return(UIImage.FromBundle("ic_render_gauge_p300"));
case EDeviceModel.P500:
return(UIImage.FromBundle("ic_render_gauge_p500"));
case EDeviceModel.P800:
return(UIImage.FromBundle("ic_render_gauge_p800"));
case EDeviceModel.PT300:
return(UIImage.FromBundle("ic_render_gauge_p300"));
case EDeviceModel.PT500:
return(UIImage.FromBundle("ic_render_gauge_p500"));
case EDeviceModel.PT800:
return(UIImage.FromBundle("ic_render_gauge_p800"));
case EDeviceModel.AV760:
return(UIImage.FromBundle("ic_render_gauge_av760"));
default:
return(UIImage.FromBundle("ic_missing.png"));
}
}
/// <summary>
/// Queries the localized string name of the given device model.
/// </summary>
/// <returns>The type string.</returns>
/// <param name="deviceModel">Device model.</param>
public static string GetTypeString(this EDeviceModel deviceModel)
{
switch (deviceModel)
{
case EDeviceModel.AV760:
return(Strings.Device.Model.AV760.FromResources());
case EDeviceModel.HT:
return(Strings.Device.Model.HT.FromResources());
case EDeviceModel.P300:
return(Strings.Device.Model.P300.FromResources());
case EDeviceModel.P500:
return(Strings.Device.Model.P500.FromResources());
case EDeviceModel.P800:
return(Strings.Device.Model.P800.FromResources());
case EDeviceModel.PT300:
return(Strings.Device.Model.PT300.FromResources());
case EDeviceModel.PT500:
return(Strings.Device.Model.PT500.FromResources());
case EDeviceModel.PT800:
return(Strings.Device.Model.PT800.FromResources());
case EDeviceModel._3XTM:
return(Strings.Device.Model._3XTM.FromResources());
default:
return(Strings.Device.Model.UNKNOWN.FromResources());
}
}
public GaugeSerialNumber(EDeviceModel model, string deviceCode, string rawSerial, DateTime manufactureDate, ushort batchId)
{
this.deviceModel = model;
this.deviceCode = deviceCode;
this.rawSerial = rawSerial;
this.manufactureDate = manufactureDate;
this.batchId = batchId;
}
public static IDevice CreateDebugDevice(IION ion, EDeviceModel deviceModel)
{
var sn = deviceModel.GenerateSerialNumber();
var factory = ion.deviceManager.deviceFactory;
var defn = factory.GetDeviceDefinition(sn);
return(defn.CreateDevice(ion, sn, new DebugConnection(sn.ToString(), "DebugAddress_" + sn.batchId), null));
}
public void SetDeviceFilter(EDeviceModel deviceModel)
{
deviceFilter = deviceModel;
deviceAdapter.SetConnections(service.GetConnectionsOfModel(deviceModel));
if (rig != null && deviceModel.AsRigType() != rig.rigType)
{
rig.Disconnect();
rig = null;
}
}
public List <IConnection> GetConnectionsOfModel(EDeviceModel deviceModel)
{
var ret = new List <IConnection>();
foreach (var connection in addressConnectionLookup.Values)
{
if (connection.serialNumber.deviceModel == deviceModel)
{
ret.Add(connection);
}
}
return(ret);
}
/// <summary>
/// Parses out a GaugeSerialNumber from the given serial. If the given serial
/// is not a valid GaugeSerialNumber we will throw an ArguementException
/// </summary>
/// <param name="serial">Serial.</param>
public static GaugeSerialNumber Parse(string serial)
{
if (serial == null)
{
/////should not throw exeptions
//throw new ArgumentException("Cannot parse serial: serial is null");
return(null);
}
// This check is not ideal, but at the time of writing the serial numbers were not solidified. I hate
// this project.
if (serial.Length == 8)
{
string rawDeviceCode = serial.Substring(0, 2);
string rawYearCode = serial.Substring(2, 2);
char rawMonthCode = serial[4];
string rawBatchId = serial.Substring(5, 3);
EDeviceModel deviceModel = DeviceModelUtils.GetDeviceModelFromCode(rawDeviceCode);
return(new GaugeSerialNumber(deviceModel, rawDeviceCode, serial, BuildManufactureDate(rawYearCode, rawMonthCode), Convert.ToUInt16(rawBatchId)));
}
else if (serial.Length == 9)
{
string rawDeviceModel = serial.Substring(0, 2);
string rawYearCode = serial.Substring(2, 2);
char rawMonthCode = serial[4];
string rawBatchId = serial.Substring(5, 4);
EDeviceModel deviceModel = DeviceModelUtils.GetDeviceModelFromCode(rawDeviceModel);
return(new GaugeSerialNumber(deviceModel, rawDeviceModel, serial, BuildManufactureDate(rawYearCode, rawMonthCode), Convert.ToUInt16(rawBatchId)));
}
else if (serial.Length == 10)
{
string rawDeviceModel = serial.Substring(0, 3);
string rawYearCode = serial.Substring(3, 2);
char rawMonthCode = serial[5];
string rawBatchId = serial.Substring(6, 4);
EDeviceModel deviceModel = DeviceModelUtils.GetDeviceModelFromCode(rawDeviceModel);
return(new GaugeSerialNumber(deviceModel, rawDeviceModel, serial, BuildManufactureDate(rawYearCode, rawMonthCode), Convert.ToUInt16(rawBatchId)));
}
else
{
/////should not throw exeptions
//throw new ArgumentException("Cannot parse serial: expected serial of length 8, 9 or 10, received length " + serial.Length);
return(null);
}
}
public static ERigType AsRigType(this EDeviceModel deviceModel)
{
switch (deviceModel)
{
case EDeviceModel.AV760:
return(ERigType.Vacuum);
case EDeviceModel.P300:
case EDeviceModel.P500:
case EDeviceModel.P800:
case EDeviceModel.PT300:
case EDeviceModel.PT500:
case EDeviceModel.PT800:
return(ERigType.Pressure);
default:
return(ERigType.Unknown);
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
handler = new Handler(Looper.MainLooper);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.activity_device_selector);
swiper = FindViewById <SwipeRefreshLayout>(Resource.Id.swiper);
list = FindViewById <RecyclerView>(Resource.Id.list);
list.SetLayoutManager(new LinearLayoutManager(this));
list.SetAdapter(deviceAdapter = new DeviceAdapter(list, FindViewById(Resource.Id.empty)));
swiper.SetOnRefreshListener(this);
startTest = FindViewById(Resource.Id.startTest);
startTest.Click += async(sender, e) => {
StartTestActivity(deviceAdapter.GetCheckedConnections());
};
startTest.Visibility = ViewStates.Gone;
deviceAdapter.onCheckChanged += (connections) => {
UpdateRigDisplay();
};
spinner = FindViewById <Spinner>(Resource.Id.spinner);
spinner.Adapter = spinnerAdapter = new SpinnerAdapter(new EDeviceModel[] {
EDeviceModel.AV760,
EDeviceModel.P800,
EDeviceModel.P500,
});
spinner.SetSelection(0);
deviceFilter = EDeviceModel.AV760;
FindViewById(Resource.Id.clear).Click += (sender, e) => {
Clear();
};
rigState = FindViewById <TextView>(Resource.Id.rigState);
// rig = null;
UpdateRigDisplay();
}
// Implemented for DataLogReport.ILocalization
public string GetDeviceModelString(EDeviceModel deviceModel)
{
return(deviceModel.GetTypeString());
}
