aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Tango.MachineStudio.UI/TFS/TeamMembersProvider.cs
blob: 464599452dc999a441c06b5d90e2ef20978b18bd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.AutoComplete.Editors;
using Tango.Core.DI;

namespace Tango.MachineStudio.UI.TFS
{
    public class TeamMembersProvider : ISuggestionProvider
    {
        public IEnumerable GetSuggestions(string filter)
        {
            var members = TangoIOC.Default.GetInstance<TeamFoundationServiceExtendedClient>().Project.Members;
            return members.Where(x => x.AssignName.ToLower().Contains(filter.ToLower()));
        }
    }
}
d.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/*
 * PowerIdle.c
 *
 *  Created on: Apr 3, 2019
 *      Author: shlomo
 */
#include "modules/General/GeneralHardware.h"
#include "modules/General/Safety.h"
#include "modules/thread/thread.h"
#include "modules/ids/ids.h"
#include "modules/control/control.h"
#include "modules/AlarmHandling/AlarmHandling.h"
#include "modules/heaters/heaters_ex.h"
#include "modules/Diagnostics/Diagnostics.h"
#include "Modules/General/process.h"
#include "PMR/MachineStatus/MachineStatus.pb-c.h"
#include "Modules/General/MachineStatus.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "InitSequence.h"

#include "drivers/I2C_Communication/DAC/Blower.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "drivers/Valves/Valve.h"
#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
#include "Modules/General/buttons.h"

#include "heaters/heaters_ex.h"

#define DEFAULT_IDLE_TIME_LIMIT 3600
int powerIdleSecondsCounter = 0;
int powerIdleSecondsLimit = DEFAULT_IDLE_TIME_LIMIT;
uint32_t IdleDrierTemperature  = 8000;
uint32_t IdleHeadTemperature = 8000;
uint32_t IdleMixerTemperature = 0;

bool powerIdleState = false;
bool machineActive = false;
uint32_t IdleControlId = 0xFF;
uint32_t IdleHeatingControlId = 0xFF;
uint32_t IdleToPowerDownControlId = 0xFF;
ProcessParameters ActiveProcessParameters,ProcessParametersClear;
bool Auto_Shutdown_Bypass = false;
bool Set_Auto_Shutdown_Bypass (int value)
{
    if (value == 0)
        Auto_Shutdown_Bypass = false;
    else
        Auto_Shutdown_Bypass = true;
    return Auto_Shutdown_Bypass;
}
bool Auto_Idle_Bypass = false;
bool Set_Auto_Idle_Bypass (int value)
{
    if (value == 0)
        Auto_Idle_Bypass = false;
    else
        Auto_Idle_Bypass = true;
    return Auto_Idle_Bypass;
}

uint32_t PowerIdleToPowerDownCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    if (SafeRemoveControlCallback(IdleToPowerDownControlId, PowerIdleToPowerDownCallBackFunction )==OK)
        IdleToPowerDownControlId = 0xFF;
    if (Auto_Shutdown_Bypass == false)
    {
        Report("PowerIdle calling power off ",__FILE__,__LINE__,(int)eOneHour*2,RpWarning,(int)0,0);
        PowerOffInit();
    }
    return OK;
}
void PowerIdleSetIdle(void)
{
    Report("PowerIdle Set ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0);
    memcpy (&ActiveProcessParameters,&ProcessParametersKeep,sizeof(ProcessParameters));
    ProcessParameters ProcessParametersClear;
    ProcessParametersClear.dryerzone1temp = (ActiveProcessParameters.dryerzone1temp<80)? ActiveProcessParameters.dryerzone1temp:IdleDrierTemperature;
    ProcessParametersClear.dryerzone2temp = (ActiveProcessParameters.dryerzone2temp<80)? ActiveProcessParameters.dryerzone2temp:IdleDrierTemperature;
    ProcessParametersClear.dryerzone3temp = (ActiveProcessParameters.dryerzone3temp<80)? ActiveProcessParameters.dryerzone3temp:IdleDrierTemperature;
    ProcessParametersClear.mixertemp      = (ActiveProcessParameters.mixertemp     <80)? ActiveProcessParameters.mixertemp     :IdleMixerTemperature;
    ProcessParametersClear.headzone1temp  = (ActiveProcessParameters.headzone1temp <80)? ActiveProcessParameters.headzone1temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone2temp  = (ActiveProcessParameters.headzone2temp <80)? ActiveProcessParameters.headzone2temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone3temp  = (ActiveProcessParameters.headzone3temp <80)? ActiveProcessParameters.headzone3temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone4temp  = (ActiveProcessParameters.headzone4temp <80)? ActiveProcessParameters.headzone4temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone5temp  = (ActiveProcessParameters.headzone5temp <80)? ActiveProcessParameters.headzone5temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone6temp  = (ActiveProcessParameters.headzone6temp <80)? ActiveProcessParameters.headzone6temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone7temp  = (ActiveProcessParameters.headzone7temp <80)? ActiveProcessParameters.headzone7temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone8temp  = (ActiveProcessParameters.headzone6temp <80)? ActiveProcessParameters.headzone6temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone9temp  = (ActiveProcessParameters.headzone9temp <80)? ActiveProcessParameters.headzone9temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone10temp  = (ActiveProcessParameters.headzone10temp <80)? ActiveProcessParameters.headzone10temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone11temp  = (ActiveProcessParameters.headzone11temp <80)? ActiveProcessParameters.headzone11temp  :IdleHeadTemperature;
    ProcessParametersClear.headzone12temp  = (ActiveProcessParameters.headzone12temp <80)? ActiveProcessParameters.headzone12temp  :IdleHeadTemperature;
    ProcessParametersClear.dyeingspeed    = (ActiveProcessParameters.dyeingspeed   <40)? ActiveProcessParameters.dyeingspeed    :IdleHeadTemperature;
    ProcessParametersClear.rblowertemp  = (ActiveProcessParameters.rblowertemp <80)? ActiveProcessParameters.rblowertemp  :IdleHeadTemperature;
    ProcessParametersClear.lblowertemp  = (ActiveProcessParameters.lblowertemp <80)? ActiveProcessParameters.lblowertemp  :IdleHeadTemperature;
    ProcessParametersClear.rblowerflow  = (ActiveProcessParameters.rblowerflow <96)? ActiveProcessParameters.rblowerflow  :96;
    ProcessParametersClear.lblowerflow  = (ActiveProcessParameters.lblowerflow <96)? ActiveProcessParameters.lblowerflow  :96;
    ProcessParametersClear.headairflow  = (ActiveProcessParameters.headairflow <3)? ActiveProcessParameters.headairflow  :3;
    if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
    {
        LOG_ERROR (1, "Turn Heaters idle failed");
        return;
    }
    if (BlowerCfg.enabled == true)
    {
        Turn_the_Blower_On();//Turn on with the Default_Voltage
        if (BlowerCfg.heatingvoltage)
            Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
        else
            Control_Voltage_To_Blower(BlowerCfg.voltage-500);
        WHS_Set_SetPoint_Q_value(headairflow/2);
    }
    SetMachineStatus(MACHINE_STATE__Sleep);
    if (Auto_Shutdown_Bypass == false)
    {
        IdleToPowerDownControlId = AddControlCallback("IdleToPowerDown",PowerIdleToPowerDownCallBackFunction, eOneHour*2, TemplateDataReadCBFunction,0,0, 0 );
    }
}

uint32_t PowerIdleCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    if (machineActive == true)
        return OK;
    if ((powerIdleSecondsCounter%100 == 0)&&(powerIdleSecondsCounter))
        Report("PowerIdle Idle counter ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0);

    if (++powerIdleSecondsCounter>=powerIdleSecondsLimit)
    {
        if ((powerIdleState == false)&&(Auto_Idle_Bypass == false))
        {
            Report("PowerIdle Idle activated ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0);
            powerIdleState = true;
            SetPowerMachineState(sttIDLE);
            //move to idle state
            PowerIdleSetIdle();
            if (SafeRemoveControlCallback(IdleControlId, PowerIdleCallBackFunction )==OK)
                IdleControlId = 0xFF;

        }
    }
    return OK;
}
void PowerIdleInit(void)
{
    IdleControlId = AddControlCallback("IdleCounter", PowerIdleCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
    if (IdleControlId == 0xFF)
        Report("AddControlCallback failed",__FILE__,__LINE__,(int)IdleControlId,RpWarning,(int)0,0);
    Report("PowerIdleInit ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)0,0);

}
void  PowerIdleSetParameters(uint32_t switchtoidletimeinseconds,uint32_t idledriertemperature,uint32_t idleheadtemperature,uint32_t idlemixertemperature)
{
    if (switchtoidletimeinseconds >= DEFAULT_IDLE_TIME_LIMIT)
        powerIdleSecondsLimit = switchtoidletimeinseconds;
    IdleDrierTemperature = idledriertemperature;
    IdleHeadTemperature = idleheadtemperature;
    IdleMixerTemperature = idlemixertemperature;
    Report("Power Idle Set Parameters",__FILE__,powerIdleSecondsLimit,(int)idledriertemperature,RpWarning,(int)idleheadtemperature,0);

}
int getIdleCounter (void) {return powerIdleSecondsCounter;}
void setIdleLimit (int Limit) {powerIdleSecondsLimit = Limit;}
void setmachineActive(bool Active){machineActive = Active;}
void resetIdleCounter (void) {powerIdleSecondsCounter = 0;}
bool getIdleState (void) {return powerIdleState;}

uint32_t PowerIdleStartHeatingCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    if (HeaterCheckReady()==true)
    {
        //MachineStateDetail = MACHINE_STATE_MACHINE_READY_TO_DYE;
        if (SafeRemoveControlCallback(IdleHeatingControlId, PowerIdleStartHeatingCallBackFunction )==OK)
            IdleHeatingControlId = 0xFF;
        else
            Report("Remove control callback failed",__FILE__,__LINE__,(int)IdleHeatingControlId,RpWarning,(int)PowerIdleStartHeatingCallBackFunction,0);
        //InitSequenceStateMachine(InitStages);
	    SetMachineStatus(MACHINE_STATE__Ready);
    }

    return OK;
}

void PowerIdleOutOfIdleState(void)
{
    Report("PowerIdle Out of Idle  ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0);
    powerIdleSecondsCounter = 0;
    if (powerIdleState == true)
    {
        powerIdleState = false;
        RemoveControlCallback(IdleToPowerDownControlId, PowerIdleToPowerDownCallBackFunction );
        IdleToPowerDownControlId = 0xFF;
        SetPowerMachineState(sttON);
        if (HandleProcessParameters(&ActiveProcessParameters,false)!= OK)
        {
            LOG_ERROR (1, "Turn Heaters active failed");
            return ;
        }
        if (IdleControlId == 0xFF)
            IdleControlId = AddControlCallback( "NULL",PowerIdleCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
        if (IdleControlId == 0xFF)
            Report("AddControlCallback failed",__FILE__,__LINE__,(int)IdleControlId,RpWarning,(int)0,0);
        SetMachineStatus(MACHINE_STATE__PowerUp);
        IdleHeatingControlId = AddControlCallback("Heating Out of Idle", PowerIdleStartHeatingCallBackFunction, 2*eOneSecond, TemplateDataReadCBFunction,0,0, 0 );


    }

}
void PowerIdleActivateIdleState(void)
{
    Report("PowerIdle Activate Idle  ",__FILE__,__LINE__,(int)machineActive,RpWarning,(int)powerIdleSecondsCounter,0);
    if (machineActive == true)
    {
        LOG_ERROR(machineActive, "machine is active, cannot switch on idle state");
        return;
    }
    powerIdleSecondsCounter = 0;
    if (powerIdleState == false)
    {
        powerIdleState = true;
        PowerIdleSetIdle();
    }

}