Software/Embedded_SW/Embedded/Communication/Container.c


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
37
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.MachineStudio.Common.Messages
{
    /// <summary>
    /// Represents an MVVM base interface for MVVM Light Messenger messages.
    /// </summary>
    public interface IStudioMessage
    {

    }
}
#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/Stubs_Handler/Stub_MidTankPressureSensor.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 "Modules/Ids/Ids_ex.h"

#include "Common/SWUpdate/FileSystem.h"
#include "Common/SWUpdate/FirmwareUpgrade.h"
#include "Communication/CommunicationTask.h"

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

#define  MAX_CONT_LOG 100

uint16_t TxmsgId[MAX_CONT_LOG+1] = {0};
uint16_t TxLength[MAX_CONT_LOG+1] = {0};
uint32_t TxAddr[MAX_CONT_LOG+1] = {0};
uint16_t Txindex = 0;
uint32_t msgId[MAX_CONT_LOG+1] = {0};
uint32_t Length[MAX_CONT_LOG+1] = {0};
uint32_t DataLength[MAX_CONT_LOG+1] = {0};
byte index = 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 = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }

    //free(response);
    return container;
}
MessageContainer createAllocatedContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*),uint8_t* response_buffer)
{
    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 = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    /*if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }*/

    //free(response);
    return container;
}

void receive_callback(char* buffer, size_t length)
{

     MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
     if (requestContainer == NULL)
         return;
   //  HeatingTestSendResonse(0, false,true,true, /*OriginalMotorSpd_2PPS[index]*/length,requestContainer->type,0,0, "Container");
    if (requestContainer->type != MESSAGE_TYPE__KeepAliveRequest) //user action resets the idle counter
    {
        resetIdleCounter();
        REPORT_MSG(requestContainer->type,"Message received");
    }
     msgId[index] = requestContainer->type;
     Length[index] = length;
     DataLength[index] = requestContainer->data.len;
     if (index++>=MAX_CONT_LOG)
         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__StubJobRequest:
             Stub_JobRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubAbortJobRequest:
             Stub_AbortJobRequest(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__CurrentJobRequest:
             CurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ResumeCurrentJobRequest:
             ResumeCurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadHardwareConfigurationRequest:
             HWConfigurationFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadProcessParametersRequest:
             ProcessRequestFunc(requestContainer);
             break;
             //functions stolen for thread load process tests
//             void ThreadLoadPollRequest(MessageContainer* requestContainer)
//             void ThreadLoadRequest(MessageContainer* requestContainer)
//             HeatingTestRequest(requestContainer);
//             HeatingTestPollRequest(requestContainer);
         case MESSAGE_TYPE__StubHeatingTestRequest:
             ThreadLoadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeatingTestPollRequest:
             ThreadLoadPollRequest(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__ResolveEventRequest:
             ResolveEventRequestFunc(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__SetDigitalOutRequest:
             SetDigitalOutRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetValveStateRequest:
             SetValveStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadJoggingRequest:
             ThreadJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadAbortJoggingRequest:
             ThreadAbortJoggingRequestFunc(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;
         case MESSAGE_TYPE__KeepAliveRequest:
             KeepAliveRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileUploadRequest:
             FileUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkUploadRequest:
             FileChunkUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileDownloadRequest:
             FileDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkDownloadRequest:
             FileChunkDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ExecuteProcessRequest:
             ExecuteProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__KillProcessRequest:
             KillProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CreateRequest:
             CreateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DeleteRequest:
             DeleteRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetStorageInfoRequest:
             GetStorageInfoRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetFilesRequest:
             GetFilesRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ActivateVersionRequest:
             ActivateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ValidateVersionRequest:
             ValidateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubMidTankPressureSensorRequest:
             Stub_MidTankPressureSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserDataRequest:
             DispenserDataRequestFunc(requestContainer);
             break;
         default:
             //unsupported message type !!
             LOG_ERROR (requestContainer->type,"unsupported message type");
             break;
     }
     message_container__free_unpacked(requestContainer, NULL);

}
bool SendResult,KeepSendResult = true;
uint16_t SendmsgId[MAX_CONT_LOG+1] = {0};
uint16_t SendSize[MAX_CONT_LOG+1] = {0};
uint32_t SendTime[MAX_CONT_LOG+1] = {0};
uint16_t Sendindex = 0;
bool SendChars(char* buffer,size_t length)
{
    SendResult = CommunicationTaskSendMessage(buffer, length);
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}
bool SendCharsWithType(char* buffer,size_t length,MessageType type)
{
    SendmsgId[Sendindex] = type;
    SendSize[Sendindex] = length;
    SendTime[Sendindex] = msec_millisecondCounter;
    if (Sendindex++>=MAX_CONT_LOG)
        Sendindex = 0;
    SendResult = CommunicationTaskSendMessage(buffer, length);
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}