public void SetDefaults()
{
version = 1;
type = "basic";
timeScale = 1;
beatsPerMinute = 120;
pulsesPerBeat = 4;
durationPerBeat = 4;
swing = 1;
sequenceQueue = new List <Sequence>();
XmlDocument doc = new XmlDocument();
doc.LoadXml("<location id=\"defaultLocation\" lat=\"0\" lon=\"0\">Default Location</location>");
currentLocation = new Location(doc.DocumentElement, this);
currentTemperature = 24f;
currentTemperatureUnits = TemperatureUnits.CELSIUS;
currentWeather = WeatherConditions.CLEAR;
currentDate = DateTime.Now;
backColor = Color.white;
midColor = Color.gray;
foreColor = Color.black;
}
public AntoinesCoefficientsExt(double c1, double c2, PressureUnits pu, TemperatureUnits tu)
{
m_pu = pu;
m_tu = tu;
m_c1 = c1;
m_c2 = c2;
}
public AntoinesCoefficientsExt()
{
m_pu = PressureUnits.mmHg;
m_tu = TemperatureUnits.Celsius;
m_c1 = Double.NaN;
m_c2 = Double.NaN;
}
public Temperature(double min, double max, double?observed, TemperatureUnits unit)
{
Min = min;
Max = max;
Observed = observed;
Unit = unit.ToString();
}
public AntoinesCoefficientsExt(double c1, double c2, double c3, double c4, double c5, double c6, double c7, double c8, double c9, PressureUnits pu, TemperatureUnits tu)
{
m_pu = pu;
m_tu = tu;
m_c1 = c1;
m_c2 = c2;
if (!double.IsNaN(c3))
{
m_c3 = c3;
}
if (!double.IsNaN(c4))
{
m_c4 = c4;
}
if (!double.IsNaN(c5))
{
m_c5 = c5;
}
if (!double.IsNaN(c6))
{
m_c6 = c6;
}
if (!double.IsNaN(c7))
{
m_c7 = c7;
}
if (!double.IsNaN(c8))
{
m_c8 = c8;
}
if (!double.IsNaN(c9))
{
m_c9 = c9;
}
}
private double ConvertTemperature(double temperature, TemperatureUnits srcUnits, TemperatureUnits resultUnits)
{
if (srcUnits != resultUnits)
{
switch (srcUnits) // Convert to celsius
{
case TemperatureUnits.Celsius:
break;
case TemperatureUnits.Kelvin:
temperature -= 273.15;
break;
}
switch (resultUnits) // Convert from celsius
{
case TemperatureUnits.Celsius:
break;
case TemperatureUnits.Kelvin:
temperature += 273.15;
break;
}
}
return(temperature);
}
public double GetPressure(double temperature, TemperatureUnits tu, PressureUnits resultUnits)
{
temperature = ConvertTemperature(temperature, tu, m_tu);
double pressure = Math.Pow(10, (A - (B / (temperature + C))));
return(ConvertPressure(pressure, m_pu, resultUnits));
}
public double GetTemperature(double pressure, PressureUnits pu, TemperatureUnits resultUnits)
{
pressure = ConvertPressure(pressure, pu, m_pu);
double temperature = B / (A - Math.Log10(pressure)) - C;
return(ConvertTemperature(temperature, m_tu, resultUnits));
}
private WeatherResult GetAverageWeatherResult(IEnumerable<WeatherResult> results, TemperatureUnits tempUnit, WindUnits windUnit)
{
WeatherResult aver = new WeatherResult();
aver.TemperatureUnit = tempUnit;
aver.WindUnit = windUnit;
aver.Temperature = 0;
aver.Wind = 0;
foreach (var weatherTemp in results)
{
aver.Temperature += weatherTemp.TemperatureUnit != tempUnit
? weatherTemp.Temperature.To(tempUnit)
: weatherTemp.Temperature;
aver.Wind += weatherTemp.WindUnit != windUnit
? weatherTemp.Wind.To(windUnit)
: weatherTemp.Wind;
}
aver.Temperature = (float)Math.Round( aver.Temperature / (float)results.Count(), 2);
aver.Wind = (float)Math.Round(aver.Wind / (float)results.Count(),2);
return aver;
}
public string ToString(TemperatureUnits units)
{
string formattedValue;
switch (units)
{
case TemperatureUnits.Celsius:
formattedValue = String.Format("{0}\u00B0 C", Celsius);
break;
case TemperatureUnits.Kelvin:
formattedValue = String.Format("{0}\u00B0 K", Kelvin);
break;
case TemperatureUnits.Fahrenheit:
formattedValue = String.Format("{0}\u00B0 F", Fahrenheit);
break;
default:
formattedValue = string.Empty;
break;
}
return(formattedValue);
}
public static WeatherDetail GetDetail(int row, WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
return(new WeatherDetail {
DetailLabel = GetLabel(row),
DetailValue = GetValue(row, location, temp, speed, length, distance, pressure),
IsSectionTop = IsSectionTop(row)
});
}
public static WeatherDetail GetDetail (int row, WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
return new WeatherDetail {
DetailLabel = GetLabel (row),
DetailValue = GetValue (row, location, temp, speed, length, distance, pressure),
IsSectionTop = IsSectionTop (row)
};
}
public AntoinesCoefficients3Impl(double a, double b, double c, PressureUnits spu, TemperatureUnits stu)
{
m_a = a;
m_b = b;
m_c = c;
m_pu = PressureUnits.mmHg;
m_tu = TemperatureUnits.Celsius;
}
public void InitalizeTest()
{
Units.Instance.Clear();
Measures.Instance.Clear();
TemperatureUnits.Initialize();
Assert.AreEqual("temperature", Measures.Instance.Find(x => x.Name == "temperature").Name);
Assert.AreEqual("Celsius", Units.Instance.Find(x => x.Name == "Celsius").Name);
}
public static List<WeatherDetail> GetDetails (WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
var list = new List<WeatherDetail> ();
for (int i = 0; i < Count; i++) list.Add (GetDetail (i, location, temp, speed, length, distance, pressure));
return list;
}
public AntoinesCoefficients3Impl()
{
m_a = Double.NaN;
m_b = Double.NaN;
m_c = Double.NaN;
m_pu = PressureUnits.mmHg;
m_tu = TemperatureUnits.Celsius;
}
/// <summary>
/// Converts the given <paramref name="value"/> measured in <paramref name="fromUOM"/> TemperatureUnits into a value of the given <paramref name="toUOM"/> TemperatureUnits and returns it.
/// </summary>
public static double ConvertUnits(this double value, TemperatureUnits fromUOM, TemperatureUnits toUOM)
{
if (fromUOM == toUOM)
{
return(value);
}
return(toUOM.ConvertFromDegK(fromUOM.ConvertToDegK(value)));
}
public ApiWeatherHttpClient(IHttpClient httpClient, string name, string url, string windKey, WindUnits windUnit, string temperatureKey, TemperatureUnits tempUnit)
{
_httpClient = httpClient;
_name = name;
_baseUri = new Uri(url);
_windKey = windKey;
_windUnit = windUnit;
_temperatureKey = temperatureKey;
_temperatureUnit = tempUnit;
}
public ApiWeatherHttpClient(IHttpClient httpClient, string name, string url, string windKey, WindUnits windUnit, string temperatureKey, TemperatureUnits tempUnit)
{
_httpClient = httpClient;
_name = name;
_baseUri = new Uri(url);
_windKey = windKey;
_windUnit = windUnit;
_temperatureKey = temperatureKey;
_temperatureUnit = tempUnit;
}
public static string ForecastString(this WuLocation location, TemperatureUnits unit)
{
var today = location?.TxtForecasts? [0];
var tonight = location?.TxtForecasts? [1];
var todayString = unit.IsImperial() ? today?.fcttext : today.fcttext_metric;
var tonightString = unit.IsImperial() ? tonight?.fcttext : tonight.fcttext_metric;
return($"{todayString}\n\nTonight: {tonightString}");
}
public static char GetTemperatureCode(this TemperatureUnits value)
{
FieldInfo field = value.GetType().GetField(value.ToString());
TemperatureCode attribute
= Attribute.GetCustomAttribute(field, typeof(TemperatureCode))
as TemperatureCode;
return(attribute == null ? 'C' : attribute.Code);
}
public static List <WeatherDetail> GetDetails(WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
var list = new List <WeatherDetail> ();
for (int i = 0; i < Count; i++)
{
list.Add(GetDetail(i, location, temp, speed, length, distance, pressure));
}
return(list);
}
/// <summary>
/// A utility method to convert from on temperature scale to another.
/// </summary>
/// <param name="fromUnit">Convert from this scale <see cref="TemperatureUnits"/>.</param>
/// <param name="toUnit">Convert to this scale <see cref="TemperatureUnits"/>.</param>
/// <param name="temperature">The temperature to convert.</param>
/// <returns>The temperature converted to the selected scale.</returns>
/// <example>Example usage:
/// <code language = "C#">
/// Debug.Print("Temperature - " + Temperature.ConvertTo(TemperatureUnits.Celsius, TemperatureUnits.Fahrenheit, sensorData.Temperature).ToString("f2") + "°F");
/// </code>
/// <code language = "VB">
/// Debug.Print("Temperature - " <![CDATA[&]]> Temperature.ConvertTo(TemperatureUnits.Celsius, TemperatureUnits.Fahrenheit, sensorData.Temperature).ToString("f2") <![CDATA[&]]> "°F")
/// </code>
/// </example>
public static float ConvertTo(TemperatureUnits fromUnit, TemperatureUnits toUnit, float temperature)
{
switch (fromUnit)
{
case TemperatureUnits.Kelvin:
{
switch (toUnit)
{
case TemperatureUnits.Celsius:
return(temperature - 273.15F);
case TemperatureUnits.Fahrenheit:
return(((temperature - 32) * 5 / 9) - 273.15F);
case TemperatureUnits.Kelvin:
return(temperature);
}
break;
}
case TemperatureUnits.Celsius:
{
switch (toUnit)
{
case TemperatureUnits.Celsius:
return(temperature);
case TemperatureUnits.Fahrenheit:
return((temperature * 9 / 5) + 32);
case TemperatureUnits.Kelvin:
return(temperature + 273.15F);
}
break;
}
case TemperatureUnits.Fahrenheit:
{
switch (toUnit)
{
case TemperatureUnits.Celsius:
return((temperature - 32) * 5 / 9);
case TemperatureUnits.Fahrenheit:
return(temperature);
case TemperatureUnits.Kelvin:
return((float)(((temperature - 32) / 1.8000) + 273.15));
}
break;
}
}
return(float.MinValue);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (!(value is Temperature) || !(parameter is TemperatureUnits))
{
return(0);
}
Temperature temperature = (Temperature)value;
TemperatureUnits temperatureUnits = (TemperatureUnits)parameter;
return(temperature.GetValueInUnits(temperatureUnits));
}
/// <summary>
/// Conver the temperature value to the specified unit
/// </summary>
/// <param name="value"></param>
/// <param name="unit"></param>
/// <returns></returns>
public static float To(this float value, TemperatureUnits unit)
{
switch (unit)
{
case TemperatureUnits.Celsius:
return((float)Math.Round((value - 32) / 1.8, 2));
case TemperatureUnits.Farenheits:
return((float)Math.Round(value * 1.8 + 32, 2));
}
throw new Exception("Unit not valid");
}
public object Convert(object value, Type targetType, object parameter, string language)
{
TemperatureUnits units = (TemperatureUnits)parameter;
int temperature = (int)value;
string text = CelciusUnitText;
if (units == TemperatureUnits.Fahrenheit)
{
temperature = (temperature * 9 / 5) + 32;
text = FahrenheitUnitText;
}
return($"{temperature:N0} {text}");
}
private void ChangeTemperature(object sender, SelectionChangedEventArgs e)
{
var Tselected = Temperature.SelectedIndex;
if (Tselected == 0)
{
TemperatureUnit = TemperatureUnits.Celsius;
}
else if (Tselected == 1)
{
TemperatureUnit = TemperatureUnits.Fahrenheit;
}
}
/// <summary>
/// Conver the temperature value to the specified unit
/// </summary>
/// <param name="value"></param>
/// <param name="unit"></param>
/// <returns></returns>
public static float To(this float value, TemperatureUnits unit)
{
switch(unit)
{
case TemperatureUnits.Celsius:
return (float)Math.Round((value - 32) / 1.8, 2);
case TemperatureUnits.Farenheits:
return (float)Math.Round(value * 1.8 + 32, 2);
}
throw new Exception("Unit not valid");
}
/// <summary>
/// Converts the given valueInDegK in Degrees Kelvin into a value of the given toUOM TemperatureUnits and returns it.
/// </summary>
public static double ConvertFromDegK(this TemperatureUnits toUOM, double valueInDegK)
{
switch (toUOM)
{
case TemperatureUnits.DegK: return(valueInDegK);
case TemperatureUnits.DegC: return(valueInDegK - Constants.DegKOffsetFromDegC);
case TemperatureUnits.DegF: return((valueInDegK - Constants.DegKOffsetFromDegC).ConvertDegCToDegF());
default: return(0.0);
}
}
/// <summary>
/// Converts the given valueInUserUnits from the given fromUOM TemperatureUnits into Degrees Kelvin and returns it.
/// </summary>
public static double ConvertToDegK(this TemperatureUnits fromUOM, double valueInUserUnits)
{
switch (fromUOM)
{
case TemperatureUnits.DegK: return(valueInUserUnits);
case TemperatureUnits.DegC: return(valueInUserUnits + Constants.DegKOffsetFromDegC);
case TemperatureUnits.DegF: return(valueInUserUnits.ConvertDegFToDegC() + Constants.DegKOffsetFromDegC);
default: return(0.0);
}
}
public double GetPressure(double temperature, TemperatureUnits tu, PressureUnits resultUnits)
{
double retval = double.NaN;
temperature = ConvertTemperature(temperature, tu, TemperatureUnits.Kelvin);
if (IsSufficientlySpecified(temperature))
{
double pressure = Math.Exp(C1 + (C2 / (temperature + C3)) + (C4 * temperature)
+ (C5 * Math.Log(temperature, Math.E)) + (C6 * Math.Pow(temperature, C7)));
retval = ConvertPressure(pressure, PressureUnits.Pascals, resultUnits);
}
return(retval);
}
public override int GetRoundToDecimalsValue()
{
TemperatureUnits toUnit = (TemperatureUnits)ToUnit;
switch (toUnit)
{
case TemperatureUnits.Celsius:
case TemperatureUnits.Kelvin:
case TemperatureUnits.Fahrentheit:
return(3);
}
throw new Exception("The 'TO' unit enum was improperly defined.");
}
public double GetValueInUnits(TemperatureUnits units)
{
switch (units)
{
case TemperatureUnits.Celsius:
return(InCelsius);
case TemperatureUnits.Fahrenheit:
return(InFahrenheit);
case TemperatureUnits.Kelvin:
return(InKelvin);
}
throw new ArgumentException("Unable to return value in" + units.ToString());
}
public string GetValueInUnits(TemperatureUnits units, int decimalPlaces)
{
switch (units)
{
case TemperatureUnits.Celsius:
return(InCelsius.ToString($"F{decimalPlaces}"));
case TemperatureUnits.Fahrenheit:
return(InFahrenheit.ToString($"F{decimalPlaces}"));
case TemperatureUnits.Kelvin:
return(InKelvin.ToString($"F{decimalPlaces}"));
}
throw new ArgumentException("Unable to return value in" + units.ToString());
}
public static string GetUnitSymbol(TemperatureUnits units)
{
switch (units)
{
case TemperatureUnits.Celsius:
return("°C");
case TemperatureUnits.Fahrenheit:
return("°F");
case TemperatureUnits.Kelvin:
return("K");
}
throw new ArgumentException("Unable to return symbol fir" + units.ToString());
}
public Temperature(double degree, TemperatureUnits units)
{
_celsius = 0;
switch (units)
{
case TemperatureUnits.Celsius:
Celsius = degree;
break;
case TemperatureUnits.Kelvin:
Kelvin = degree;
break;
case TemperatureUnits.Fahrenheit:
Fahrenheit = degree;
break;
default:
throw new NotSupportedException();
}
}
public async Task<WeatherResult> GetWeatherAsync(string location, TemperatureUnits tempUnit, WindUnits windUnit)
{
WeatherResult result=null;
List<Task<WeatherResult>> tasks = new List<Task<WeatherResult>>();
foreach (var api in _apiClients)
{
tasks.Add(api.GetWeather(location));
}
//Await until all the calls to GetWeather have finished.
await Task.WhenAll(tasks);
var interResults = tasks.Where(t=> t.Result!= null).Select(t => t.Result);
if ( interResults.Any()) result = this.GetAverageWeatherResult(interResults,tempUnit, windUnit);
return result;
}
public static string GetValue (int row, WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
var conditions = location?.Conditions;
if (conditions == null) return string.Empty;
switch (row) {
case 0: return conditions.FeelsLikeString (temp, true, true);
case 1: return location.SunriseString ();
case 2: return location.SunsetString ();
case 3: return location.ProbabilityPercipString ();
case 4: return conditions.relative_humidity;
case 5: return conditions.WindString (speed);
case 6: return conditions.GustString (speed);
case 7: return conditions.PrecipTodayString (length);
case 8: return conditions.PressureString (pressure);
case 9: return conditions.VisibilityString (distance);
case 10: return location.Conditions.UV.ToString ();
default: return string.Empty;
}
}
public string ToString(TemperatureUnits units)
{
string formattedValue;
switch (units)
{
case TemperatureUnits.Celsius:
formattedValue = String.Format("{0}\u00B0 C", Celsius);
break;
case TemperatureUnits.Kelvin:
formattedValue = String.Format("{0}\u00B0 K", Kelvin);
break;
case TemperatureUnits.Fahrenheit:
formattedValue = String.Format("{0}\u00B0 F", Fahrenheit);
break;
default:
formattedValue = string.Empty;
break;
}
return formattedValue;
}
public void SetDefaults()
{
version = 1;
type = "basic";
sequenceQueue = new List<Sequence>();
XmlDocument doc = new XmlDocument();
doc.LoadXml( "<location id=\"defaultLocation\" lat=\"0\" lon=\"0\">Default Location</location>" );
currentLocation = new Location( doc.DocumentElement, this );
currentTemperature = 24f;
currentTemperatureUnits = TemperatureUnits.CELSIUS;
currentWeather = WeatherConditions.CLEAR;
currentDate = DateTime.Now;
}
/**
* Given a temperature, makes it the current temperature.
*
* @param temperature The temperature to make current.
*/
public void SetTemperature( float temperature, TemperatureUnits units )
{
currentTemperature = temperature;
currentTemperatureUnits = units;
}
public static double LowTemp (this ForecastDay forecast, TemperatureUnits units, bool round = false) => getValueInUnits (units, forecast?.low?.FahrenheitValue, forecast?.low?.CelsiusValue, round);
public static double FeelsLike (this CurrentObservation observation, TemperatureUnits units, bool round = false) => getValueInUnits (units, observation?.feelslike_f, observation?.feelslike_c, round);
public static string LowTempString (this WuLocation location, TemperatureUnits units, bool round = false, bool degreeSymbol = false) => getTemperatureString (location.TodayForecast.LowTemp (units, round), degreeSymbol);
public static string ForecastString (this WuLocation location, TemperatureUnits unit)
{
var today = location?.TxtForecasts? [0];
var tonight = location?.TxtForecasts? [1];
var todayString = unit.IsImperial () ? today?.fcttext : today.fcttext_metric;
var tonightString = unit.IsImperial () ? tonight?.fcttext : tonight.fcttext_metric;
return $"{todayString}\n\nTonight: {tonightString}";
}
//====================================================
/// <summary>
/// Restores the API flags
/// </summary>
//====================================================
internal override void RestoreApiFlags()
{
m_valueUnits = m_valueUnitsClone;
m_units = m_unitsClone;
base.RestoreApiFlags();
}
public void ParseCommand()
{
switch ( command ) {
case "speak":
if ( data.Attributes.GetNamedItem( "tone" ) != null ) {
tone = (SpeechTone) System.Enum.Parse ( typeof(SpeechTone), data.Attributes.GetNamedItem( "tone" ).InnerXml.ToUpper() );
}
break;
case "settemperature":
if ( data.Attributes.GetNamedItem( "units" ) != null ) {
units = (TemperatureUnits) System.Enum.Parse ( typeof(TemperatureUnits), data.Attributes.GetNamedItem( "units" ).InnerXml.ToUpper() );
} else {
units = TemperatureUnits.CELSIUS;
}
break;
case "setweather":
weather = content != null ? (WeatherConditions) System.Enum.Parse ( typeof(WeatherConditions), content.ToUpper() ) : WeatherConditions.CLEAR;
break;
case "setdate":
case "settime":
date = DateTime.Parse( content );
break;
case "setsequence":
if ( data.Attributes.GetNamedItem( "atDate" ) != null ) {
atDate = DateTime.Parse( data.Attributes.GetNamedItem( "atDate" ).InnerXml );
}
if ( data.Attributes.GetNamedItem( "autoStart" ) != null ) {
autoStart = data.Attributes.GetNamedItem( "autoStart" ).InnerXml == "true" ? true : false;
}
break;
}
}
public static double Temp (this HourlyForecast forecast, TemperatureUnits units, bool round = false) => getValueInUnits (units, forecast?.temp?.english, forecast?.temp?.metric, round);
public static string TempString (this WuLocation location, TemperatureUnits units, bool round = false, bool degreeSymbol = false) => getTemperatureString (location.Conditions.Temp (units, round), degreeSymbol);
public static double Temp (this CurrentObservation observation, TemperatureUnits units, bool round = false) => getValueInUnits (units, observation?.temp_f, observation?.temp_c, round);
//===========================================================================================
/// <summary>
/// Validates the Ai Value message
/// </summary>
/// <param name="message">The message</param>
/// <returns>An error code</returns>
//===========================================================================================
internal override ErrorCodes ProcessValueGetMessage(int channel, ref string message)
{
m_voltsOnly = false;
if (message.Contains(string.Format("?AI{0}:VALUE", MessageTranslator.GetChannelSpecs(channel))) && m_tcTypes[channel] == ThermocoupleTypes.NotSet)
{
return ErrorCodes.ThermocoupleTypeNotSet;
}
ErrorCodes errorCode = ValidateValueMsgUnits(channel, message);
if (errorCode != ErrorCodes.NoErrors)
return errorCode;
m_aiChannelType[channel] = GetChannelType(channel);
if (m_aiChannelType[channel] == AiChannelTypes.Temperature)
{
// set the clones for restoring original flags after SendMessage is complete
m_calibrateDataClone = m_calibrateData;
m_scaleDataClone = m_scaleData;
m_unitsClone = m_units;
m_valueUnitsClone = m_valueUnits;
//m_units = TemperatureUnits.None;
//m_valueUnits = String.Empty;
//m_calibrateData = false;
//m_scaleData = false;
// read the CJC value in deg C...
m_daqDevice.SendMessageDirect(string.Format("?AI{0}:CJC/DEGC", MessageTranslator.GetChannelSpecs(channel)));
m_cjcValues[channel] = m_daqDevice.DriverInterface.ReadValueDirect();
if (message.Contains(string.Format("VALUE/RAW", MessageTranslator.GetChannelSpecs(channel))))
{
m_calibrateData = false;
m_scaleData = false;
m_valueUnits = "/RAW";
message = MessageTranslator.RemoveValueResolver(message);
return ErrorCodes.NoErrors;
}
if (message.Contains(string.Format("VALUE/VOLTS", MessageTranslator.GetChannelSpecs(channel))))
{
m_calibrateData = true;
m_scaleData = true;
m_valueUnits = "/VOLTS";
message = MessageTranslator.RemoveValueResolver(message);
return ErrorCodes.NoErrors;
}
if (message.Contains(string.Format("VALUE/DEGC", MessageTranslator.GetChannelSpecs(channel))))
{
m_calibrateData = true;
m_scaleData = true;
m_valueUnits = "/DEGC";
message = MessageTranslator.RemoveValueResolver(message);
m_units = TemperatureUnits.Celsius;
return ErrorCodes.NoErrors;
}
if (message.Contains(string.Format("VALUE/DEGF", MessageTranslator.GetChannelSpecs(channel))))
{
//m_isAiData = true;
m_calibrateData = true;
m_scaleData = true;
m_valueUnits = "/DEGF";
message = MessageTranslator.RemoveValueResolver(message);
m_units = TemperatureUnits.Fahrenheit;
return ErrorCodes.NoErrors;
}
if (message.Contains(string.Format("VALUE/KELVIN", MessageTranslator.GetChannelSpecs(channel))))
{
//m_isAiData = true;
m_calibrateData = true;
m_scaleData = true;
m_valueUnits = "/KELVIN";
message = MessageTranslator.RemoveValueResolver(message);
m_units = TemperatureUnits.Kelvin;
return ErrorCodes.NoErrors;
}
else if (m_UseTempUnits)
{
// This is an undocumented feature for Kona ... DAQFlex customers should never get here.
//
// This allows the use of TEMPUNITS with a message that is of the form
// AI{0}:VALUE (no /DEGC, /DEGF, or /KELVIN).
m_calibrateData = true;
m_scaleData = true;
return ErrorCodes.NoErrors;
}
}
else
base.ProcessValueGetMessage(channel, ref message);
return ErrorCodes.NoErrors;
}
static double getValueInUnits (TemperatureUnits units, double? imperial, double? metric, bool round = false) => getValueInUnits (units.IsImperial (), imperial, metric, round);
//====================================================================================
/// <summary>
/// Overridden method for processing a temp units message
/// </summary>
/// <param name="message">The device message</param>
//====================================================================================
internal override ErrorCodes ProcessTempUnitsMessage(string message)
{
if (message[0] == Constants.QUERY)
{
if (m_valueUnits == string.Empty)
m_daqDevice.ApiResponse = new DaqResponse(message.Remove(0, 1) + "=" + m_units.ToString(), double.NaN);
else
m_daqDevice.ApiResponse = new DaqResponse(message.Remove(0, 1) + "=" + m_valueUnits.Remove(0, 1), double.NaN);
m_daqDevice.SendMessageToDevice = false;
return ErrorCodes.NoErrors;
}
else
{
if (message.Contains("DEGC"))
{
m_units = TemperatureUnits.Celsius;
m_valueUnits = "/DEGC";
m_UseTempUnits = true;
}
else if (message.Contains("DEGF"))
{
m_units = TemperatureUnits.Fahrenheit;
m_valueUnits = "/DEGF";
m_UseTempUnits = true;
}
else if (message.Contains("KELVIN"))
{
m_units = TemperatureUnits.Kelvin;
m_valueUnits = "/KELVIN";
m_UseTempUnits = true;
}
else
{
m_units = TemperatureUnits.Volts;
m_valueUnits = "/VOLTS";
m_UseTempUnits = true;
}
if (message.Contains("AISCAN"))
{
m_unitsClone = m_units;
}
m_daqDevice.ApiResponse = new DaqResponse(MessageTranslator.ExtractResponse(message), double.NaN);
m_daqDevice.SendMessageToDevice = false;
return ErrorCodes.NoErrors;
}
}
public static string TempString (this HourlyForecast forecast, TemperatureUnits units, bool round = false, bool degreeSymbol = false) => getTemperatureString (forecast.Temp (units, round), degreeSymbol);
public static double DewPoint (this CurrentObservation observation, TemperatureUnits units, bool round = false) => getValueInUnits (units, observation?.dewpoint_f, observation?.dewpoint_c, round);
public static string DewPointString (this CurrentObservation observation, TemperatureUnits units, bool round = false, bool degreeSymbol = false) => getTemperatureString (observation.DewPoint (units, round), degreeSymbol);
public static string LowTempString (this ForecastDay forecast, TemperatureUnits units, bool round = false, bool degreeSymbol = false) => getTemperatureString (forecast.LowTemp (units, round), degreeSymbol);
