aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/TechnicianModeLoginView.xaml.cs
blob: 3a809b6f3da5c3825ffd6ef1efc028795b4aa893 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Tango.PPC.UI.Dialogs
{
    /// <summary>
    /// Interaction logic for TechnicianModeLoginView.xaml
    /// </summary>
    public partial class TechnicianModeLoginView : UserControl
    {
        public TechnicianModeLoginView()
        {
            InitializeComponent();

            Loaded += TechnicianModeLoginView_Loaded;
        }

        private async void TechnicianModeLoginView_Loaded(object sender, RoutedEventArgs e)
        {
            await Task.Delay(200);
            txtPassword.Focus();
        }
    }
}
light .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 */
/*
 * DiagnosticsJogging.c
 *
 *  Created on: 16 aug 2018
 *      Author: shlomo
 */
#include <DataDef.h>
#include "include.h"

#include <inc/hw_ints.h>
#include <Container.h>

#include "diagnostics.h"
#include "drivers/Motors/Motor.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/FPGA/FPGA.h"

#include  <PMR/Diagnostics/DispenserJoggingRequest.pb-c.h>
#include  <PMR/Diagnostics/DispenserJoggingResponse.pb-c.h>
#include  <PMR/Diagnostics/DispenserAbortJoggingRequest.pb-c.h>
#include  <PMR/Diagnostics/DispenserAbortJoggingResponse.pb-c.h>

#include  <PMR/Diagnostics/MotorJoggingRequest.pb-c.h>
#include  <PMR/Diagnostics/MotorJoggingResponse.pb-c.h>
#include  <PMR/Diagnostics/MotorAbortJoggingRequest.pb-c.h>
#include  <PMR/Diagnostics/MotorAbortJoggingResponse.pb-c.h>

#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/Motors/Motor.h"
#include "drivers/Valves/Valve.h"

#include "modules/ids/ids_ex.h"
#include "StateMachines/Printing/PrintingSTM.h"

/********************************************************************************
 * Motor Jogging
 ********************************************************************************/

uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
{
    uint32_t status = OK;
    bool allowedInJob  =true;

    MessageContainer responseContainer;

    MotorJoggingRequest* request = motor_jogging_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    MotorJoggingResponse response = MOTOR_JOGGING_RESPONSE__INIT;

    TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
    bool direction;
    int speed = request->speed;
    if (speed == 0) speed = 150;

    if (JobIsActive() == true)
    {
        switch (MotorId)
        {
            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4:
            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8:
            case HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING:case HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM:case HARDWARE_MOTOR_TYPE__MOTO_SCREW:case HARDWARE_MOTOR_TYPE__MOTO_WINDER:
            case HARDWARE_MOTOR_TYPE__MOTO_LDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_LLOADING:case HARDWARE_MOTOR_TYPE__MOTO_RDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_RLOADING:
                allowedInJob = false;
                break;
            default:
                break;
        }
    }
    if (MotorId <= NUM_OF_MOTORS)
    {
        if ((allowedInJob == true)&&(isMotorConfigured(MotorId) == true))
        {
            {
                switch (request->direction)
                {
                    case MOTOR_DIRECTION__Forward:
                        direction = MotorsCfg[MotorId].directionthreadwize;
                        break;
                    case MOTOR_DIRECTION__Backward:
                        direction = 1-MotorsCfg[MotorId].directionthreadwize;
                        break;
                }
                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                {
                    uint32_t Pos_Value = ((direction == 1)?0:2);
                    Report("MotorJoggingRequestFunc Dryer lid",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,direction,RpMessage,Pos_Value,0);
                    MotorGoTo(MotorId, Pos_Value );
                }
                else
                {
                    MotorSetDirection(MotorId,direction);
                    MotorSetSpeed(MotorId, speed);
                }
            }
        }
        else
        {
            status = ERROR;
        }
    }
    else
    {
        status = ERROR;
    }

    responseContainer = createContainer(MESSAGE_TYPE__MotorJoggingResponse,  requestContainer->token, false, &response, &motor_jogging_response__pack, &motor_jogging_response__get_packed_size);
    if (status!= OK)
    {
        responseContainer.has_error = true;
        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
        responseContainer.errormessage = "JOb Active or incorrect parameters";
    }
    responseContainer.continuous = false;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);

    return OK;
}

uint32_t MotorAbortJoggingRequestFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    MotorAbortJoggingRequest* request = motor_abort_jogging_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    MotorAbortJoggingResponse response = MOTOR_ABORT_JOGGING_RESPONSE__INIT;

    TimerMotors_t MotorId = (TimerMotors_t)request->motortype;

    MotorStop(MotorId,Hard_Hiz);
    if (MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
        MotorStop(MotorId,Hard_Stop );

    responseContainer = createContainer(MESSAGE_TYPE__MotorAbortJoggingResponse,  requestContainer->token, false, &response, &motor_abort_jogging_response__pack, &motor_abort_jogging_response__get_packed_size);
    responseContainer.continuous = false;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);

    return OK;
}

/********************************************************************************
 * Dispenser Jogging
 ********************************************************************************/
extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];

uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
{
    uint32_t status = OK;

    MessageContainer responseContainer;

    DispenserJoggingRequest* request = dispenser_jogging_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    DispenserJoggingResponse response = DISPENSER_JOGGING_RESPONSE__INIT;

    TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
    int speed = request->speed;
    if (speed == 0) speed = 150;

    bool direction;

    if (MotorId <= NUM_OF_MOTORS)
    {
//        if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
        if (isMotorConfigured(MotorId) == true)
        {
            switch (request->direction)
            {
                case MOTOR_DIRECTION__Forward:
                    Control3WayValvesWithCallback ((Valves_t) request->index, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
                    SysCtlDelay(180000);
                    direction = MotorsCfg[MotorId].directionthreadwize;
                    if (request->index == LUBRICANT_DISPENSER)
                    {
                        REPORT_MSG (request->index, "Open lubrication valve");
                        Lubricant_2Way_Valve (START);
                    }
                    break;
                case MOTOR_DIRECTION__Backward:
                    Control3WayValvesWithCallback ((Valves_t) request->index, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
                    SysCtlDelay(180000);
                    direction = 1-MotorsCfg[MotorId].directionthreadwize;
                    break;
            }
            MotorSetDirection(MotorId,direction);
            MotorSetSpeed(MotorId, speed);
            CurrentDispenserSpeed[request->index] = speed;
            if(request->direction == MOTOR_DIRECTION__Backward)
                CurrentDispenserSpeed[request->index] *= (-1);

        }
        else
        {
            status = ERROR;
        }
    }
    else
    {
        status = ERROR;
    }

    responseContainer = createContainer(MESSAGE_TYPE__DispenserJoggingResponse,  requestContainer->token, false, &response, &dispenser_jogging_response__pack, &dispenser_jogging_response__get_packed_size);
    if (status!= OK)
    {
        responseContainer.has_error = true;
        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
        responseContainer.errormessage = "JOb Active or incorrect parameters";
    }
    responseContainer.continuous = false;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);

    return OK;
}
uint32_t DispenserAbortJoggingRequestFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    DispenserAbortJoggingRequest* request = dispenser_abort_jogging_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    DispenserAbortJoggingResponse response = DISPENSER_ABORT_JOGGING_RESPONSE__INIT;

    TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
    MotorStop(MotorId,Hard_Hiz);
    CurrentDispenserSpeed[request->index] = 0;
    Control3WayValvesWithCallback ((Valves_t) request->index, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer

    if (request->index == LUBRICANT_DISPENSER)
    {
        REPORT_MSG (request->index, "Close lubrication valve");
        Lubricant_2Way_Valve (STOP);
    }

    responseContainer = createContainer(MESSAGE_TYPE__DispenserAbortJoggingResponse,  requestContainer->token, false, &response, &dispenser_abort_jogging_response__pack, &dispenser_abort_jogging_response__get_packed_size);
    responseContainer.continuous = false;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);

    return OK;
}