TemperaturePresenter.cs

00001 /*******************************************************************************
00002 * Copyright (C) 2016 Maxim Integrated Products, Inc., All rights Reserved.
00003 * 
00004 * This software is protected by copyright laws of the United States and
00005 * of foreign countries. This material may also be protected by patent laws
00006 * and technology transfer regulations of the United States and of foreign
00007 * countries. This software is furnished under a license agreement and/or a
00008 * nondisclosure agreement and may only be used or reproduced in accordance
00009 * with the terms of those agreements. Dissemination of this information to
00010 * any party or parties not specified in the license agreement and/or
00011 * nondisclosure agreement is expressly prohibited.
00012 *
00013 * The above copyright notice and this permission notice shall be included
00014 * in all copies or substantial portions of the Software.
00015 *
00016 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00017 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00018 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00019 * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
00020 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
00021 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
00022 * OTHER DEALINGS IN THE SOFTWARE.
00023 *
00024 * Except as contained in this notice, the name of Maxim Integrated
00025 * Products, Inc. shall not be used except as stated in the Maxim Integrated
00026 * Products, Inc. Branding Policy.
00027 *
00028 * The mere transfer of this software does not imply any licenses
00029 * of trade secrets, proprietary technology, copyrights, patents,
00030 * trademarks, maskwork rights, or any other form of intellectual
00031 * property whatsoever. Maxim Integrated Products, Inc. retains all
00032 * ownership rights.
00033 *******************************************************************************
00034 */
00035 
00036 using System;
00037 using System.Collections.Generic;
00038 using System.Linq;
00039 using System.Text;
00040 using System.Threading.Tasks;
00041 using System.Timers;
00042 using System.Windows.Forms;
00043 using MAX30205EVKit.Model;
00044 using MAX30205EVKit.View;
00045 
00046 using HealthSensorPlatform.CustomControls;
00047 using HealthSensorPlatform;
00048 
00049 using Maxim.Utility;
00050 
00051 namespace MAX30205EVKit.Presenter
00052 {
00053     class TemperaturePresenter 
00054     {
00055         ITemperatureModel[] model;
00056         ITemperatureView view;
00057         IDeviceView connected;
00058         //IFileLogView fileLogView;
00059 
00060         TemperatureValue temperature;
00061         TemperatureValue overTemperature;
00062         TemperatureValue hystersis;
00063 
00064         //bool firstTime = true;
00065         //double time = 0.0;
00066 
00067         public TemperaturePresenter(ITemperatureModel[] model, IDeviceView connected, ITemperatureView view) 
00068         {
00069             this.model = model;
00070             this.view = view;
00071             this.connected = connected;
00072 
00073             //this.fileLogView = fileLogView;
00074 
00075             view.ReadAll += new EventHandler<EventArgs>(OnReadAll);
00076             view.RequestReadTemperature += new EventHandler<EventArgs>(OnReadTemperature);
00077             view.OverTemperatureChanged += new EventHandler<TemperatureEventArgs>(OnOverTemperatureChanged);
00078             view.HystersisChanged += new EventHandler<TemperatureEventArgs>(OnHystersisChanged);
00079             view.WriteRegister += new EventHandler<WriteRegisterEventArgs>(OnWriteRegister);
00080             view.DataFormatChanged += new EventHandler<DataFormatEventArgs>(OnDataFormatChanged);
00081         }
00082 
00083         /*
00084         public TemperaturePresenter(ITemperatureModel model, IDeviceView connected, ITemperatureView view, IFileLogView fileLogView)
00085         {
00086             this.model = model;
00087             this.view = view;
00088             this.connected = connected;
00089 
00090             this.fileLogView = fileLogView;
00091 
00092             view.ReadAll += new EventHandler<EventArgs>(OnReadAll);
00093             view.RequestReadTemperature += new EventHandler<EventArgs>(OnReadTemperature);
00094             view.OverTemperatureChanged += new EventHandler<TemperatureEventArgs>(OnOverTemperatureChanged);
00095             view.HystersisChanged += new EventHandler<TemperatureEventArgs>(OnHystersisChanged);
00096             view.WriteRegister += new EventHandler<WriteRegisterEventArgs>(OnWriteRegister);
00097 
00098         } 
00099         */
00100 
00101         public void WriteRegister(int index, int register, int data)
00102         {
00103             if (connected.Connected)
00104                 model[index].RegWrite(register, data);
00105         }
00106 
00107         public void OnReadAll(object sender, EventArgs e)
00108         {
00109             int temperatureHex;
00110             int configuration;
00111             int hystersisHex;
00112             int overTemperatureHex;
00113 
00114 
00115             if (connected.Connected)
00116             {
00117                 for (int i = 0; i < model.Length; i++)
00118                 {
00119                     temperatureHex = model[i].RegRead(0x00);
00120                     configuration = model[i].RegRead(0x01);
00121                     hystersisHex = model[i].RegRead(0x02);
00122                     overTemperatureHex = model[i].RegRead(0x03);
00123 
00124                     temperature = new TemperatureValue(temperatureHex, model[i].DataFormat);
00125                     overTemperature = new TemperatureValue(overTemperatureHex, model[i].DataFormat);
00126                     hystersis = new TemperatureValue(hystersisHex, model[i].DataFormat);
00127 
00128                     view.DisplayTemperature(i, temperature);
00129                     view.DisplayConfigurationRegister(i, configuration);
00130                     view.DisplayOverTemperature(i, overTemperature);
00131                     view.DisplayHysteresis(i, hystersis);
00132                 }
00133             }
00134         }
00135 
00136         public void OnDataFormatChanged(object sender, DataFormatEventArgs e)
00137         {
00138             int hysteresisHex = model[e.Index].Registers[0x02];
00139             int overtemperature = model[e.Index].Registers[0x03];
00140 
00141             if (connected.Connected)
00142             {
00143                 overTemperature = new TemperatureValue(overtemperature, e.DataFormat);
00144                 hystersis = new TemperatureValue(hysteresisHex, e.DataFormat);
00145 
00146                 view.DisplayOverTemperature(e.Index, overTemperature);
00147                 view.DisplayHysteresis(e.Index, hystersis);
00148             }
00149         }
00150 
00151         void OnReadTemperature(object sender, EventArgs e)
00152         {
00153             if (connected.Connected)
00154             {
00155                 for (int i = 0; i < model.Length; i++)
00156                 {
00157                     int configuration = model[i].RegRead(0x01);
00158 
00159                     //model[i].RegWrite(0x01, configuration | 0x81);
00160                     model[i].RegWrite(0x01, configuration | 0x80);
00161                     System.Threading.Thread.Sleep(50);
00162                     int temp = model[i].RegRead(0x00);
00163 
00164                     TemperatureValue tempValue = new TemperatureValue(temp, model[i].DataFormat);
00165                     view.DisplayTemperature(i, tempValue);
00166 
00167                     //If user chooses to log Temperature, write lines to CSV
00168                     WriteTempToFileLog(tempValue);
00169                 }
00170             }
00171         }
00172 
00173 
00174 
00175         void OnOverTemperatureChanged(object sender, TemperatureEventArgs e)
00176         {
00177             if (!IsWithinRange(e.Temperature.ToString(), model[e.Index].DataFormat))
00178                 view.DisplayError(e.Control, "Temperature Out of Range");
00179             else
00180             {
00181                 overTemperature = new TemperatureValue(e.Temperature, model[e.Index].DataFormat);
00182 
00183                 view.DisplayOverTemperature(e.Index, overTemperature);
00184 
00185                 if (connected.Connected)
00186                     model[e.Index].RegWrite(0x03, overTemperature.TemperatureHex);
00187             }
00188             
00189         }
00190 
00191         void OnHystersisChanged(object sender, TemperatureEventArgs e)
00192         {
00193             if (!IsWithinRange(e.Temperature.ToString(), model[e.Index].DataFormat))
00194                 view.DisplayError(e.Control, "Temperature Out of Range");
00195             else
00196             {
00197                 hystersis = new TemperatureValue(e.Temperature, model[e.Index].DataFormat);
00198 
00199                 view.DisplayHysteresis(e.Index, hystersis);
00200 
00201                 if (connected.Connected)
00202                     model[e.Index].RegWrite(0x02, hystersis.TemperatureHex);
00203             }
00204 
00205             
00206         }
00207 
00208         void OnWriteRegister(object sender, WriteRegisterEventArgs e)
00209         {
00210             WriteRegister(e.Index, e.Register, e.Data);
00211         }
00212 
00213         void WriteTempToFileLog(TemperatureValue tempValue)
00214         {
00215             /*
00216             if (fileLogView.Enable)
00217             {
00218                 if (firstTime)
00219                 {
00220                     firstTime = false;
00221                     fileLogView.WriteLine("Time (s), Temperature (°C)");
00222                 }
00223                 else
00224                 {
00225                     time = time + view.RefreshRate;
00226                 }
00227                 var temp = Math.Round(tempValue.TemperatureC, 3);
00228                 fileLogView.WriteTemp(time, temp);
00229             }
00230              */
00231         }
00232 
00233         bool IsWithinRange(string str, bool dataFormat)
00234         {
00235             double temp;
00236             if (Double.TryParse(str, out temp))
00237             {
00238                 if (!dataFormat)
00239 
00240                     return (temp >= -128.00) && (temp < 127.997);
00241 
00242                 return (temp >= -64.00) && (temp < 191.997);
00243             }
00244 
00245             return false;
00246         }
00247 
00248         /*        void OnTimerTick(object sender, ElapsedEventArgs e)
00249                 {
00250                     if (connected.Connected)
00251                     {
00252                         int temperature;
00253 
00254                         model.RegWrite(0x01, model.Registers[0x01] | 0x81);
00255                         System.Threading.Thread.Sleep(50);
00256                         temperature = model.RegRead(0x00);
00257 
00258                         TemperatureValue tempValue = new TemperatureValue(temperature, model.DataFormat);
00259                         view.DisplayTemperature(0, tempValue);
00260                     }
00261                 }*/
00262 
00263 
00264 
00265         /*        double hexToTemperature(int hex, bool dataFormat, bool unitCelsius)
00266                 {
00267                     int normalCode;
00268                     int rawCode = hex;
00269                     double celsius;
00270 
00271                     if (rawCode > 0x7fff)
00272                         normalCode = rawCode - 0x10000;
00273                     else
00274                         normalCode = rawCode;
00275 
00276                     if (dataFormat == false)
00277                         celsius = normalCode / Math.Pow(2, 8);
00278                     else
00279                         celsius = normalCode / Math.Pow(2, 8) + 64;
00280 
00281                     if (unitCelsius == true)
00282                         return celsius;
00283                     else
00284                         return celsiusToFahrenheit(celsius);
00285 
00286                 }*/
00287 
00288         //        short temperatureToHex(double temperature)
00289         //        {
00290         //            return (short)(temperature * Math.Pow(2, 8));
00291         //        }
00292         //
00293         //        double celsiusToFahrenheit(double temperature)
00294         //        {
00295         //            return temperature * 9 / 5 + 32;
00296         //        }
00297 
00298     }
00299 }