//////////////////////////////////////////////////////////////// 
// 
// PURPOSE: This contains ScienceModule parameters for Tethys.
//
// NOTES:   All values (except "strings") must be followed by
//          a unit abbreviation (or one of the unit-like
//          abbreviations: n/a, bool, enum, count). 
// 
//////////////////////////////////////////////////////////////// 

   Aanderaa_O2.loadAtStartup          = 0 bool;
   Aanderaa_O2.simulateHardware     = 1 bool;
   Aanderaa_O2.power           = 0.42 watt;
   Aanderaa_O2.model           = "";

   CANONSampler.loadAtStartup = 0 bool;
   CANONSampler.simulateHardware = 0 bool;
   CANONSampler.sampleTimeout = 6 minute;
   CANONSampler.rotateOnly = 0 bool;

   CTD_NeilBrown.loadAtStartup           = 1 bool;
   CTD_NeilBrown.simulateHardware      = 1 bool;   
   CTD_NeilBrown.power            = 0.29 watt;
   CTD_NeilBrown.maxPressBound    = 500 decibar;
   CTD_NeilBrown.minPressBound    = -10 decibar;
   CTD_NeilBrown.offset           = 0 decibar;
   CTD_NeilBrown.maxSalinityBound = 38 psu;
   CTD_NeilBrown.minSalinityBound = 28 psu;

   CTD_Seabird.loadAtStartup           = 0 bool;
   CTD_Seabird.simulateHardware      = 1 bool;
   CTD_Seabird.maxPressBound    = 500 decibar;
   CTD_Seabird.minPressBound    = -10 decibar;
   CTD_Seabird.maxSalinityBound = 38 psu;
   CTD_Seabird.minSalinityBound = 28 psu;   
   
   ESPComponent.loadAtStartup          = 0 bool;
   ESPComponent.simulateHardware       = 0 bool;
   ESPComponent.power                  = 10 watt;
   ESPComponent.debug                  = 0 bool;
   ESPComponent.espLogFilterRegex      = "Selecting Cartridge|Sampled|Error|Fail|Retry|Cmd::|Sampler::";  // if non-empty, regex to select lines from ESP log in final report upon sampling completion
   ESPComponent.endFiltering           = 0 bool;      // set to true in mission file to explicitly request the ESP to end ongoing filtering
   ESPComponent.socketServerPort       = 9999 count;  // used when LRAUV starts as a server (then waiting for the ESP to connect as a client)
   ESPComponent.espServerHost          = "";          // when non-empty must have the format "hostname:portNumber", indicating where the ESP is listening as a server
   ESPComponent.poTimeout              = 150 second;  // to wait for ESP to connect once it's powered on
   ESPComponent.connectTimeout         = 30 second;   // to connect as client to the ESP
   ESPComponent.sampleTimeout          = 30 minute;   // only applies when simulateHardware is true; otherwise, the overall sample timeout is the aggregation of the following timeouts
   ESPComponent.initialPromptTimeout   = 20 second;
   ESPComponent.loadCartridgeTimeout   = 10 minute;
   ESPComponent.filterResultTimeout    = 30 second;
   ESPComponent.filterCompleteTimeout  = 120 minute;   // Per Brent, 120min to allow for error masking (previously 90min)
   ESPComponent.processResultTimeout   = 30 second;
   ESPComponent.processCompleteTimeout = 90 minute;    // This allows for Surface Plasmon Resonance (SPR) analytics to run. 
   ESPComponent.stopResultTimeout      = 2 minute;
   ESPComponent.pppConnect = "linkname esp noauth local lock 115200 134.89.10.51:134.89.10.60 persist maxfail 0 holdoff 10 lcp-echo-interval 60 lcp-echo-failure 3 proxyarp ktune deflate 12 ms-dns 134.89.10.32 ms-dns 134.89.10.10";
   ESPComponent.pppFlow = "xonxoff asyncmap A0000";
   
   ISUS.loadAtStartup                 = 0 bool;
   ISUS.simulateHardware            = 1 bool;   
   ISUS.power                  = 7.78 watt;
   ISUS.nitrateAccuracy        = 4 umol/l;

   PAR_Licor.loadAtStartup      = 1 bool;
   PAR_Licor.simulateHardware = 1 bool;
   PAR_Licor.serial      = "UWQ4562";
   PAR_Licor.darkCount   = 930 count;
   PAR_Licor.adcCal      = 5.90145e-6 uA/count; // = Vref/gain/ohms/ADCRange*1e6 uA/A ~= 2.5/101/2000/2^21*1e6
   PAR_Licor.multiplier  = 315.79 umol/s/m2/uA; // from calibration sheet
   PAR_Licor.maxBound    = 3600 umol/s/m2;
   PAR_Licor.minBound    = 0 umol/s/m2;
   PAR_Licor.maxValidPitch = 25 degree;
   PAR_Licor.minValidPitch = 15 degree;

   Turner_Cyclops_rhodamine.loadAtStartup      = 0 bool;
   Turner_Cyclops_rhodamine.simulateHardware = 0 bool;
   Turner_Cyclops_rhodamine.serial      = "TBD";
   Turner_Cyclops_rhodamine.scale = 2.384 microvolt; // per count of A/D
   Turner_Cyclops_rhodamine.maxBound    = 36000 ppb;
   Turner_Cyclops_rhodamine.minBound    = 0 ppb;
   Turner_Cyclops_rhodamine.concentrationStandard = 10 ppb;
   Turner_Cyclops_rhodamine.voltageStandard = 0.5 volt;
   Turner_Cyclops_rhodamine.voltageBlank    = 0.4 volt;
   
   Turbulence_NPS.loadAtStartup          = 0 bool;
   Turbulence_NPS.simulateHardware     = 1 bool;
   Turbulence_NPS.power           = 2.0 watt;

   VemcoVR2C.loadAtStartup      = 0 bool;
   VemcoVR2C.simulateHardware   = 0 bool;
   VemcoVR2C0.power             = 0.18 watt
   
   WetLabsBB2FL.loadAtStartup    = 1 bool;
   WetLabsBB2FL.simulateHardware = 1 bool;
   WetLabsBB2FL.power          = 0.75 watt;
   WetLabsBB2FL.timeout        = 15 s;
   WetLabsBB2FL.period         = 0.400 s;
   WetLabsBB2FL.serial         = "";
   WetLabsBB2FL.scaleFactor470 = NaN 1/m/sr/count;
   WetLabsBB2FL.darkCounts470  = -1 count;
   WetLabsBB2FL.scaleFactor650 = NaN 1/m/sr/count;
   WetLabsBB2FL.darkCounts650  = -1 count;
   WetLabsBB2FL.scaleFactorChl = NaN ug/l/count;
   WetLabsBB2FL.darkCountsChl  = -1 count;
   WetLabsBB2FL.chlAccuracy    = NaN ug/l;
   
   WetLabsSeaOWL_UV_A.loadAtStartup    = 0 bool;
   WetLabsSeaOWL_UV_A.simulateHardware = 1 bool;
   WetLabsSeaOWL_UV_A.power          = 0.75 watt;
   WetLabsSeaOWL_UV_A.timeout        = 15 s;
   WetLabsSeaOWL_UV_A.period         = 0.400 s;
   WetLabsSeaOWL_UV_A.serial         = "";
   WetLabsSeaOWL_UV_A.scaleFactor700 = NaN 1/m/sr/count;
   WetLabsSeaOWL_UV_A.darkCounts700  = -1 count;
   WetLabsSeaOWL_UV_A.scaleFactorFDOM = NaN ppb/count;
   WetLabsSeaOWL_UV_A.darkCountsFDOM  = -1 count;
   WetLabsSeaOWL_UV_A.fdomAccuracy    = NaN ppb;
   WetLabsSeaOWL_UV_A.scaleFactorChl = NaN ug/l/count;
   WetLabsSeaOWL_UV_A.darkCountsChl  = -1 count;
   WetLabsSeaOWL_UV_A.chlAccuracy    = NaN ug/l;
   WetLabsSeaOWL_UV_A.scaleFactorOil = NaN ppb/count;
   WetLabsSeaOWL_UV_A.darkCountsOil  = -1 count;
   WetLabsSeaOWL_UV_A.oilAccuracy    = NaN ppb;
   WetLabsSeaOWL_UV_A.chlAccuracy    = 0.0180 ug/l;
   
   WetLabsUBAT.loadAtStartup = 0 bool;
   WetLabsUBAT.simulateHardware = 0 bool;