Esempio n. 1
0
        protected void SetChannelSettings(int channelIn, HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration rampingConfigIn)
        {
            logger.Debug("SetChannelSettings; Channel: {0} OvershootOffset: {1}, OvershootDuration: {2} P: {3} I: {4} D: {5}",
                         channelIn.ToString(),
                         rampingConfigIn.m_fOvershootOffset.ToString(),
                         rampingConfigIn.m_uiOvershootDuration.ToString(),
                         rampingConfigIn.m_PID_Settings[0].m_fPGain.ToString(),
                         rampingConfigIn.m_PID_Settings[0].m_fIGain.ToString(),
                         rampingConfigIn.m_PID_Settings[0].m_fDGain.ToString()
                         );

            _theModel.tecBoard.theBoard.SetSampleTime(channelIn, 0.1f);

            _theModel.tecBoard.theBoard.SetOvershootDuration(channelIn, 0, rampingConfigIn.m_uiOvershootDuration);
            _theModel.tecBoard.theBoard.SetOvershootOffset(channelIn, 0, rampingConfigIn.m_fOvershootOffset);

            _theModel.tecBoard.theBoard.SetOvershootDuration(channelIn, 1, rampingConfigIn.m_uiOvershootDuration);
            _theModel.tecBoard.theBoard.SetOvershootOffset(channelIn, 1, rampingConfigIn.m_fOvershootOffset);

            _theModel.tecBoard.theBoard.SetSetPointOffset(channelIn, rampingConfigIn.m_fSetpointOffset);

            _theModel.tecBoard.theBoard.TECSetPID_D(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fDGain);
            _theModel.tecBoard.theBoard.TECSetPID_I(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fIGain);
            _theModel.tecBoard.theBoard.TECSetPID_P(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fPGain);
            _theModel.tecBoard.theBoard.SetRabbitGain(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fRabbitGain);
            _theModel.tecBoard.theBoard.SetRabbitGain2(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fRabbitGain2);
            _theModel.tecBoard.theBoard.SetRabbitGainDeriv(channelIn, 0, rampingConfigIn.m_PID_Settings[0].m_fRabbitDerivGain);

            _theModel.tecBoard.theBoard.TECSetPID_D(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fDGain);
            _theModel.tecBoard.theBoard.TECSetPID_I(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fIGain);
            _theModel.tecBoard.theBoard.TECSetPID_P(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fPGain);
            _theModel.tecBoard.theBoard.SetRabbitGain(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fRabbitGain);
            _theModel.tecBoard.theBoard.SetRabbitGain2(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fRabbitGain2);
            _theModel.tecBoard.theBoard.SetRabbitGainDeriv(channelIn, 1, rampingConfigIn.m_PID_Settings[1].m_fRabbitDerivGain);

            _theModel.tecBoard.theBoard.SetErrorTermBand(channelIn, 50);
            _theModel.tecBoard.theBoard.SetErrorTermCounts(channelIn, 255);
            _theModel.tecBoard.theBoard.SetPBand(channelIn, 6);
            _theModel.tecBoard.theBoard.SetPowerLimitCounts(channelIn, 255);
            _theModel.tecBoard.theBoard.SetTempControlMode(channelIn, 1);
            _theModel.tecBoard.theBoard.SetLowClamp(channelIn, -100);
            _theModel.tecBoard.theBoard.SetHighClamp(channelIn, 300);
        }
Esempio n. 2
0
        /// <summary>
        /// Selects the PID parameters for the specified temperature range.
        /// </summary>
        /// <returns></returns>
        public HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration SelectThermalParameters(float fromTemp, float toTemp, List <HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element> rangeList)
        {
            HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration configOut = null;

            foreach (HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element element in rangeList)
            {
                if (fromTemp >= element.m_TemperatureRange.m_fLowTemperature &&
                    fromTemp <= element.m_TemperatureRange.m_fHighTemperature
                    )
                {
                    foreach (HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration rampingConfig in element.m_ToTemperatures)
                    {
                        if (toTemp >= rampingConfig.m_TemperatureRange.m_fLowTemperature &&
                            toTemp <= rampingConfig.m_TemperatureRange.m_fHighTemperature)
                        {
                            configOut = rampingConfig;

                            logger.Debug("DevicePCRCycler SelectThermalParameters, found a plan; curTemp is {4} making settings for the temperature range: From: {0}-{1} To: {2}-{3}",
                                         element.m_TemperatureRange.m_fLowTemperature.ToString(),
                                         element.m_TemperatureRange.m_fHighTemperature.ToString(),
                                         configOut.m_TemperatureRange.m_fLowTemperature.ToString(),
                                         configOut.m_TemperatureRange.m_fHighTemperature.ToString(),
                                         fromTemp.ToString()
                                         );
                        }
                    }
                }
            }

            // Hopefully we've got our plan now.

            if (configOut == null)
            {
                logger.Debug("DevicePCRCycler SelectThermalParameters did not find a plan for {0} to {1}.",
                             fromTemp.ToString(), toTemp.ToString());
            }

            return(configOut);
        }
Esempio n. 3
0
        /// <summary>
        /// Sets the temperature parameters to the appropriate settings for this temperature band.
        /// </summary>
        /// <param name="curTemp"></param>
        /// <param name="rangeList"></param>
        public void SetToAppropriateBand(int nChannel, float curTemp, double toTemp, List <HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element> rangeList)
        {
            //logger.Debug("DevicePCRCycler SetToAppropriateBand starting");

            // If our target is outside our current targets.

            if (!_theModel.bUnderTempPlan[nChannel] && !_theModel.bStopScript)
            {
                logger.Debug("DevicePCRCycler SetToAppropriateBand, finding a new band, curTemp is {0} to temp is {1}", curTemp.ToString(),
                             toTemp.ToString());
                // Find a new plan.
                HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration rampingConfig = SelectThermalParameters(curTemp, (float)toTemp, rangeList);

                if (rampingConfig != null)
                {
                    SetChannelSettings(nChannel, rampingConfig);

                    // _theModel.tecBoard.theBoard.SetFanDutyCycle(100);
                    // _theModel.tecBoard.theBoard.EnableSystemFan(true);
                    // _theModel.tecBoard.theBoard.EnableTECFan(true);

                    // Record the range we've currently set up.

                    _rampingLowTemp[nChannel]  = rampingConfig.m_TemperatureRange.m_fLowTemperature;
                    _rampingHighTemp[nChannel] = rampingConfig.m_TemperatureRange.m_fHighTemperature;

                    _theModel.bUnderTempPlan[nChannel] = true;
                }
                else
                {
                    // TBD; there is a default somewhere.
                }
            }

            //logger.Debug("DevicePCRCycler SetToAppropriateBand exitting");
        }
Esempio n. 4
0
        /// <summary>
        /// Selects the PID parameters for the specified temperature range.
        /// </summary>
        /// <returns></returns>
        public HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration SelectThermalParameters(float fromTemp, float toTemp, List <HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element> rangeList)
        {
            HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration configOut = null;

            // Scan one, locate the plan that has the tightest from range.

            float fromRangeDelta = -1;
            int   ndxRange       = -1;
            int   ndx            = 0;

            foreach (HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element element in rangeList)
            {
                if (fromTemp >= element.m_TemperatureRange.m_fLowTemperature &&
                    fromTemp <= element.m_TemperatureRange.m_fHighTemperature
                    )
                {
                    if (fromRangeDelta == -1)
                    {
                        // Grab this one if it's the first one.

                        fromRangeDelta = Math.Abs(element.m_TemperatureRange.m_fHighTemperature - element.m_TemperatureRange.m_fLowTemperature);
                        ndxRange       = ndx;
                    }
                    else
                    {
                        // Use this one if it's tighter.

                        float localFromRangeDelta = Math.Abs(element.m_TemperatureRange.m_fHighTemperature - element.m_TemperatureRange.m_fLowTemperature);

                        if (localFromRangeDelta < fromRangeDelta)
                        {
                            fromRangeDelta = localFromRangeDelta;
                            ndxRange       = ndx;
                        }
                    }
                }

                ndx++;
            }

            // If we found a range.

            if (ndxRange != -1)
            {
                HelixGen.Model.Configuration.CTEC_From_Temperature_PID_Element configElement = rangeList[ndxRange];

                // Find the tightest to range.

                float toRangeDelta = -1;
                int   ndxToRange   = -1;
                ndx = 0;

                foreach (HelixGen.Model.Configuration.CTEC_HW_Ramping_Configuration rampingConfig in configElement.m_ToTemperatures)
                {
                    if (toTemp >= rampingConfig.m_TemperatureRange.m_fLowTemperature &&
                        toTemp <= rampingConfig.m_TemperatureRange.m_fHighTemperature)
                    {
                        if (toRangeDelta == -1)
                        {
                            toRangeDelta = Math.Abs(rampingConfig.m_TemperatureRange.m_fHighTemperature - rampingConfig.m_TemperatureRange.m_fLowTemperature);
                            ndxToRange   = ndx;
                        }
                        else
                        {
                            float localToRangeDelta = Math.Abs(rampingConfig.m_TemperatureRange.m_fHighTemperature - rampingConfig.m_TemperatureRange.m_fLowTemperature);

                            if (localToRangeDelta < toRangeDelta)
                            {
                                toRangeDelta = Math.Abs(rampingConfig.m_TemperatureRange.m_fHighTemperature - rampingConfig.m_TemperatureRange.m_fLowTemperature);
                                ndxToRange   = ndx;
                            }
                        }
                    }

                    ndx++;
                }

                // Hopefully we've got our plan now.

                if (ndxToRange != -1)
                {
                    configOut = configElement.m_ToTemperatures[ndxToRange];

                    logger.Debug("DevicePCRCycler SelectThermalParameters, found a plan; curTemp is {4} making settings for the temperature range: From: {0}-{1} To: {2}-{3}",
                                 configElement.m_TemperatureRange.m_fLowTemperature.ToString(),
                                 configElement.m_TemperatureRange.m_fHighTemperature.ToString(),
                                 configOut.m_TemperatureRange.m_fLowTemperature.ToString(),
                                 configOut.m_TemperatureRange.m_fHighTemperature.ToString(),
                                 fromTemp.ToString()
                                 );
                }
                else
                {
                    logger.Debug("DevicePCRCycler SelectThermalParameters did not find a plan for {0} to {1}.",
                                 fromTemp.ToString(), toTemp.ToString());
                }
            }

            return(configOut);
        }