aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/MachineStudio.Dispensers/Contracts/IMainView.cs
blob: ea0744c84e844ddfe98918bf60e63859e774e611 (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.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.SharedUI;

namespace Tango.MachineStudio.Dispensers.Contracts
{
    public enum DispensersNavigationView
    {
        DispensersView,
        DispenserView,
    }

    public interface IMainView : IView
    {
        void NavigateTo(DispensersNavigationView view);
    }
}
#include <PMR/Common/MessageContainer.pb-c.h>
#include "include.h"
#include "driverlib/gpio.h"

//#include "usb_serial_adapter.h"
//#include "graphics_adapter.h"
#include "Modules/Stubs_Handler/Calculate.h"
#include "Modules/Stubs_Handler/Progress.h"
#include "Modules/Stubs_Handler/Stub_Cartridge.h"
#include "Modules/Stubs_Handler/Stub_Dispenser.h"
#include "Modules/Stubs_Handler/Stub_GPIO.h"
#include "Modules/Stubs_Handler/Stub_Heater.h"
#include "Modules/Stubs_Handler/Stub_OptLimitSwitch.h"
#include "Modules/Stubs_Handler/Stub_SteperMotor.h"
#include "Modules/Stubs_Handler/Stub_Valve.h"
#include "Modules/Stubs_Handler/Stub_ExtFlash.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadBackReg.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadVersion.h"
#include "Modules/Stubs_Handler/Stub_L6470.h"
#include "Modules/Stubs_Handler/Stub_Motor.h"
#include "Modules/Stubs_Handler/Stub_HW_Version.h"
#include "Modules/Stubs_Handler/Stub_FPGARWReg.h"
#include "Modules/Stubs_Handler/Stub_ReadEmbeddedVersion.h"
#include "Modules/Stubs_Handler/Stub_TivaReg.h"
#include "Modules/Stubs_Handler/Stub_Dancer.h"
#include "Modules/Stubs_Handler/Stub_SpeedSensor.h"
#include "Modules/Stubs_Handler/Stub_IntADC.h"
#include "Modules/Stubs_Handler/StubRealTimeUsage.h"
#include "Modules/Stubs_Handler/Stub_TempSensor.h"
#include "Modules/Stubs_Handler/Stub_I2C.h"

#include "Modules/General/GeneralHardware.h"
#include "Modules/heaters/heaters_ex.h"
#include "Modules/AlarmHandling/AlarmHandling.h"
#include "modules/Diagnostics/Diagnostics.h"

#include "Modules/General/process.h"
#include "Modules/Thread/Thread_ex.h"

#include "Communication/CommunicationTask.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "Common/report/report.h"
#include "Connection.h"


uint32_t TxmsgId[50] = {0};
uint32_t TxLength[50] = {0};
byte Txindex = 0;

MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*))
{
    MessageContainer container = MESSAGE_CONTAINER__INIT;
    container.completed = completed;
    container.token = token;
    container.has_completed = true;
    container.has_data = true;
    container.has_type = true;
    container.type = type;



    uint8_t* response_buffer = malloc((*sizePtr)(response));
    size_t response_size = (*packPtr)(response, response_buffer);
    container.data.data = response_buffer;
    container.data.len = response_size;
    TxmsgId[Txindex] = type;
    TxLength[Txindex] = response_size;
    if (Txindex++>=50)
        Txindex = 0;

    //free(response);
    return container;
}
uint32_t msgId[50] = {0};
uint32_t Length[50] = {0};
uint32_t DataLength[50] = {0};
byte index = 0;

void receive_callback(char* buffer, size_t length)
{

     MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
   //  HeatingTestSendResonse(0, false,true,true, /*OriginalMotorSpd_2PPS[index]*/length,requestContainer->type,0,0, "Container");

     msgId[index] = requestContainer->type;
     Length[index] = length;
     DataLength[index] = requestContainer->data.len;
     if (index++>=50)
         index = 0;
     switch(requestContainer->type)
     {
         case MESSAGE_TYPE__CalculateRequest:
             Stub_CalculateRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ProgressRequest:
             Stub_ProgressRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeReadRequest:
             Stub_CartridgeReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeWriteRequest:
             Stub_CartridgeWriteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubDispenserRequest:
             Stub_DispenserRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOInputSetupRequest:
             Stub_GPIOInputSetupRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadBitRequest:
             Stub_GPIOReadBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadByteRequest:
             Stub_GPIOReadByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteBitRequest:
             Stub_GPIOWriteBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteByteRequest:
             Stub_GPIOWriteByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeaterRequest:
             Stub_HeaterRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CRequest:
             Stub_I2CRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubOptLimitSwitchRequest:
             Stub_OptLimitSwitchRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubSteperMotorRequest:
             Stub_SteperMotorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubValveRequest:
             Stub_ValveRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubExtFlashReadRequest:
             Stub_ExtFlashReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubExtFlashWriteRequest:
             Stub_ExtFlashWriteRequest(requestContainer);
             break;
		case MESSAGE_TYPE__StubFPGAReadBackRegRequest:
             Stub_FPGAReadBackRegRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubFPGAReadVersionRequest:
             Stub_FPGAReadVersionRequest(requestContainer);
             break;
             /*************************************/
         case MESSAGE_TYPE__StubFpgaReadRegRequest:
             Stub_FpgaReadRegRequest(requestContainer);
             break;
         case    MESSAGE_TYPE__StubFpgaWriteRegRequest:
             Stub_FpgaWriteRegRequest(requestContainer);
             break;
             /*************************************/
         case MESSAGE_TYPE__StubL6470DriverRequest:
             Stub_L6470DriverRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorInitRequest:
             Stub_MotorInitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRunRequest:
             Stub_MotorRunRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStopRequest:
             Stub_MotorStopRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStatusRequest:
             Stub_MotorStatusRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorPositionRequest:
             Stub_MotorPositionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorSpeedRequest:
             Stub_MotorSpeedRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRequest:
             Stub_MotorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorMovRequest:
             Stub_MotorMovRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHWVersionRequest:
             Stub_HWVersionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StartDebugLogRequest:
             ReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__StopDebugLogRequest:
             StopReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__JobRequest:
             JobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortJobRequest:
             JobAbortFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadHardwareConfigurationRequest:
             HWConfigurationFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadProcessParametersRequest:
             ProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeatingTestRequest:
             HeatingTestRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeatingTestPollRequest:
             HeatingTestPollRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubReadEmbeddedVersionRequest:
             Stub_ReadEmbeddedVersionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__SystemResetRequest:
             HWSystemResetRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubTivaReadRegRequest:
             Stub_TivaReadRegRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubTivaWriteRegRequest:
             Stub_TivaWriteRegRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubDancerPositionRequest:
             Stub_DancerPositionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubSpeedSensorRequest:
             Stub_SpeedSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubRealTimeUsageRequest:
             Stub_RealTimeUsageRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubIntADCReadRequest:
             Stub_IntADCReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubTempSensorRequest:
             Stub_TempSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ConnectRequest:
             ConnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DisconnectRequest:
             DisconnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StartDiagnosticsRequest:
             StartDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopDiagnosticsRequest:
             StopDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartEventsNotificationRequest:
             StartEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopEventsNotificationRequest:
             StopEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortHomingRequest:
            MotorAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorHomingRequest:
            MotorHomingRequestFunc(requestContainer);
            break;
         case MESSAGE_TYPE__MotorJoggingRequest:
            MotorJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortJoggingRequest:
            MotorAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortHomingRequest:
            DispenserAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserHomingRequest:
            DispenserHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserJoggingRequest:
            DispenserJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortJoggingRequest:
            DispenserAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetComponentValueRequest:
             SetComponentValueRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CReadBytesRequest:
             Stub_I2CReadBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CWriteBytesRequest:
             Stub_I2CWriteBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubExtFlashWriteWordsRequest:
             Stub_ExtFlashWriteWordsRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubExtFlashReadWordsRequest:
             Stub_ExtFlashReadWordsRequest(requestContainer);
             break;

         default:
             //unsupported message type !!
             LOG_ERROR (requestContainer->type,"unsupported message type");
             break;
     }
     message_container__free_unpacked(requestContainer, NULL);

}
bool SendChars(char* buffer,size_t length)
{
    return CommunicationTaskSendMessage(buffer, length);
}