path: root/Software/Embedded_SW/Embedded/Common/report/reportInit.c

/******************************************************************************
 * File name    :  reportInit.c
 * Title        :  REPORT PACKAGE - Application Interface
 * Date created :  01 SEP, 1996
 * Revision     :  1.0
 * Author       :  Ilia Maller, Zvika Zilberman
 *
 * Description  :  
 * 
 ******************************************************************************
 *
 * Procedures:
 *
 *		ReportInit		- Initialise report package
 *
 ******************************************************************************
 *
 * History:
 * 01.09.96 Ilia Maller - start of coding
 * 21.02.97 Ilia Maller - minor improvements
 * 17.09.97 Zvika Zilberman - porting to DCME SWINFRA
 *
 ******************************************************************************/

/*------------- Includes --------------------------------*/

#include <Container.h>
#include <DataDef.h>
#include <stdio.h>		/* puts(), etc. */
#include "report.h"
#include "distributor.h"	/* distibutorInit */
#include "filter.h"
#include "include.h"

#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/debugging/StartDebugLogRequest.pb-c.h"
#include "PMR/debugging/StopDebugLogRequest.pb-c.h"
#include "PMR/debugging/StartDebugLogResponse.pb-c.h"
#include "PMR/debugging/StopDebugLogResponse.pb-c.h"
#include "PMR/debugging/SetDebugLogCategoryRequest.pb-c.h"
#include "PMR/debugging/SetDebugLogCategoryResponse.pb-c.h"
#include "PMR/debugging/DebugDistributor.pb-c.h"
#include "PMR/debugging/SetupDebugDisributorsRequest.pb-c.h"
#include "PMR/debugging/SetupDebugDisributorsResponse.pb-c.h"

#include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"

#include "modules/General/process.h"
#include "AlarmHandling/AlarmHandling.h"

#include "Common/SW_Info/SW_Info.h"

PackageHandle ControlFilter;
PackageHandle HeatersFilter;
PackageHandle JobFilter  ;
PackageHandle WasteFilter  ;
PackageHandle AlarmFilter  ;
PackageHandle DiagnosticsFilter;
PackageHandle IDSFilter;
PackageHandle ThreadFilter;
PackageHandle GeneralFilter;
PackageHandle CommFilter;
PackageHandle FPGAFilter;
PackageHandle LoadFilter;
PackageHandle InitFilter;
PackageHandle MaintFilter;
PackageHandle IFSFilter;
PackageHandle FilesFilter;
PackageHandle I2CFilter;
PackageHandle MotorFilter;

char LogPath[50] = "0://ErrFile.txt";

char protobufToken[36+1] = {0};
char RepMessage[300];
FRESULT LogFresult = FR_OK;
FIL *LogFileHandle = 0;  //the system supports a single active file
bool isReportActive(void)
{
    if (protobufToken[0] == 0)
    {
        return false;
    }
    return true;
}
uint32_t OpenLogFile(void)
{
#ifdef STORE_DEBUG_LOGS
    int len;
    uint32_t Bytes = 0;
    LogFileHandle = my_malloc(sizeof(FIL));
    if (LogFileHandle)
    {
        LogFresult = f_open(LogFileHandle,LogPath,FA_READ | FA_WRITE | FA_OPEN_ALWAYS);
        if (LogFresult == FR_OK)
        {
            if (LogFileHandle->fsize < 100000)
                f_lseek(LogFileHandle, LogFileHandle->fsize);
            else
            {
                f_lseek(LogFileHandle, 0);
                f_truncate (LogFileHandle);
            }
            len = usnprintf(RepMessage, 80, "\r\n*******\r\nLog File start %d/%d/%d %d:%d:%d",LocalTime.tm_mday,LocalTime.tm_mon+1,LocalTime.tm_year,LocalTime.tm_hour,LocalTime.tm_min,LocalTime.tm_sec);
            LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
            ReportResetReason();
        }
    }
    else
        LogFresult = FR_INT_ERR;

    return LogFresult;
#else
    return OK;
#endif
}
uint32_t CloseLogFile(void)
{
    /* perform default error output */
#ifdef STORE_DEBUG_LOGS
    int len;
    uint32_t Bytes = 0;
    len = usnprintf(RepMessage, 80, "\r\n*******\r\nClosing Log File %d/%d/%d %d:%d:%d",LocalTime.tm_mday,LocalTime.tm_mon+1,LocalTime.tm_year,LocalTime.tm_hour,LocalTime.tm_min,LocalTime.tm_sec);
    LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
    LogFresult = f_close(LogFileHandle);
    LogFileHandle = NULL;
    return LogFresult;
#else
    return OK;
#endif

}
uint32_t LogToFile(char *message,       /* The formatted message                */
                   char *FileName,
                   int LineNumber,
                       int errorCode,       /* error code that caused the report    */
                       int Severity,      /* user parameter no. 1                 */
                       int parameter)
{

        /* print user supplied error code */
#ifdef STORE_DEBUG_LOGS
    uint32_t Bytes = 0;
    int len;
    if (LogFileHandle == NULL)
        return OK;

    len = usnprintf(RepMessage, 300, "\r\n %d:%d:%d %s ,file %s\t  line %d\t code %d\t sev %d,\tparam %d",LocalTime.tm_hour,LocalTime.tm_min,LocalTime.tm_sec,message,FileName, LineNumber,errorCode, Severity, parameter);
    LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );

    return LogFresult;
#else
    return OK;
#endif
}
int ReportResponseFunc(char *message,       /* The formatted message                */
                       char *FileName,
                       int LineNumber,
                           int errorCode,       /* error code that caused the report    */
                           int Severity,      /* user parameter no. 1                 */
                           int parameter)     /* user parameter no. 2                 */
{
    MessageContainer responseContainer;
    if (protobufToken[0] == 0)
    {
		return OK;
    }
    StartDebugLogResponse response = START_DEBUG_LOG_RESPONSE__INIT;
    response.filename = FileName;
    response.has_linenumber = true;
    response.linenumber = LineNumber;
    response.has_moduleid = true;
    response.moduleid = errorCode;
    /*response.has_severity = true;
    response.severity = (Severity)parameter1;*/
    response.has_filter = true;
    response.filter = parameter;
    response.has_category = true;
    switch (Severity)
    {
        case RpMessage:
            response.category = DEBUG_LOG_CATEGORY__Info;
            break;
        case RpWarning:
            response.category = DEBUG_LOG_CATEGORY__Warning;
            break;
        case RpError:
            response.category = DEBUG_LOG_CATEGORY__Error;
            break;
        case RpFatalError:
            response.category = DEBUG_LOG_CATEGORY__Critical;
            break;
        case RpPrivate:
        default:
            response.category = DEBUG_LOG_CATEGORY__Info;
            break;
    }
    response.message = message;
        responseContainer = /*Report*/createContainer(MESSAGE_TYPE__StartDebugLogResponse, protobufToken, false, &response, &start_debug_log_response__pack, &start_debug_log_response__get_packed_size);
        responseContainer.has_continuous = true;
        responseContainer.continuous = true;
        //if (responseContainer.data.data)
        {
            uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
            if (container_buffer)
            {
                size_t container_size = message_container__pack(&responseContainer, container_buffer);
                //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
                if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartDebugLogResponse) == false) //comm tx mailbox full
                {
                    //CommunicationMailboxFlush();
                    protobufToken[0] = 0;
                    my_free(container_buffer);
                }
            }
            my_free(responseContainer.data.data);
        }
        //Task_sleep(5);
    return OK;

}
char ResetMessage[200];
void SetupDebugDisributorsRequestFunc(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;
    uint8_t* container_buffer;
    uint32_t status = 0;

    SetupDebugDisributorsRequest* request = setup_debug_disributors_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    SetupDebugDisributorsResponse response = SETUP_DEBUG_DISRIBUTORS_RESPONSE__INIT;

    responseContainer = createContainer(MESSAGE_TYPE__SetupDebugDisributorsResponse, requestContainer->token, true, &response, &setup_debug_disributors_response__pack, &setup_debug_disributors_response__get_packed_size);
    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));

    switch (request->debugdistributor  )
    {
        case DEBUG_DISTRIBUTOR_TYPE__ControlFilter:
            status|=ReportSwitchPackageFilter(ControlFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__HeatersFilter:
            status|=ReportSwitchPackageFilter(HeatersFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__JobFilter:
            status|=ReportSwitchPackageFilter(JobFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__WasteFilter:
            status|=ReportSwitchPackageFilter(WasteFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__AlarmFilter:
            status|=ReportSwitchPackageFilter(AlarmFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__DiagnosticsFilter:
            status|=ReportSwitchPackageFilter(DiagnosticsFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__IDSFilter:
            status|=ReportSwitchPackageFilter(IDSFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__ThreadFilter:
            status|=ReportSwitchPackageFilter(ThreadFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__GeneralFilter:
            status|=ReportSwitchPackageFilter(GeneralFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__CommFilter:
            status|=ReportSwitchPackageFilter(CommFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__FPGAFilter:
            status|=ReportSwitchPackageFilter(FPGAFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__LoadFilter:
            status|=ReportSwitchPackageFilter(LoadFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__InitFilter:
            status|=ReportSwitchPackageFilter(InitFilter   , request->distributoractive);
            break;
        case DEBUG_DISTRIBUTOR_TYPE__MaintFilter:
            status|=ReportSwitchPackageFilter(MaintFilter   , request->distributoractive);
            break;
        default:
            status = ERROR_CODE__INVALID_PARAMETER;
            ReportWithPackageFilter(GeneralFilter,"SetupDebugDisributorsRequest error",__FILE__,__LINE__,request->has_debugdistributor,RpWarning,0,  0);
            break;
    }
    if (status)
    {
        responseContainer.has_error = true;
        responseContainer.error = (ErrorCode)status;
    }
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);
    setup_debug_disributors_request__free_unpacked(request,NULL);

}
char SerMessage[50];
uint32_t ReportResetReason(void)
{
    /*
     #define SYSCTL_CAUSE_HSRVREQ    0x00001000  // Hardware System Service Request
     #define SYSCTL_CAUSE_HIB        0x00000040  // Hibernate reset
     #define SYSCTL_CAUSE_WDOG1      0x00000020  // Watchdog 1 reset
     #define SYSCTL_CAUSE_SW         0x00000010  // Software reset
     #define SYSCTL_CAUSE_WDOG0      0x00000008  // Watchdog 0 reset
     #define SYSCTL_CAUSE_BOR        0x00000004  // Brown-out reset
     #define SYSCTL_CAUSE_POR        0x00000002  // Power on reset
     #define SYSCTL_CAUSE_EXT        0x00000001  // External reset
     */
    uint32_t RESC = SysCtlResetCauseGet();

    memset (ResetMessage,0,sizeof(ResetMessage));
    strcpy(ResetMessage, "Reset Reason Register");
    if (RESC & SYSCTL_CAUSE_HSRVREQ)
        strcat(ResetMessage, ", Service Req");

    if (RESC & SYSCTL_CAUSE_HIB)
        strcat(ResetMessage, ", Hibernate");

    if (RESC & SYSCTL_CAUSE_WDOG1)
        strcat(ResetMessage, ", Watchdog 1");

    if (RESC & SYSCTL_CAUSE_SW)
        strcat(ResetMessage, ", Software");

    if (RESC & SYSCTL_CAUSE_WDOG0)
        strcat(ResetMessage, ", Watchdog 0");

    if (RESC & SYSCTL_CAUSE_BOR)
        strcat(ResetMessage, ", Brown-out");

    if (RESC & SYSCTL_CAUSE_POR)
        strcat(ResetMessage, ", Power on");

    if (RESC & SYSCTL_CAUSE_EXT)
        strcat(ResetMessage, ", External");

    Report(ResetMessage, __FILE__, __LINE__, RESC, RpWarning, RESC, 0);

    if ((RESC & SYSCTL_CAUSE_WDOG1)||(RESC & SYSCTL_CAUSE_WDOG0)||(RESC & SYSCTL_CAUSE_BOR))
        AlarmHandlingSetAlarm (EVENT_TYPE__UNINTENDED_RESET,ON);  //handle alarm detection and operation

    return RESC;

}

uint32_t ReportInitMessage(MessageContainer* requestContainer)
{
    uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;

//    ReportInitParams InitParams;

    StartDebugLogRequest* request = start_debug_log_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    Report("==============Saving file=================", __FILE__, __LINE__, _gTangoVersion.m_patch, RpWarning, _gTangoVersion.m_build, 0);
    Task_sleep (100);
    ustrncpy (protobufToken, requestContainer->token,36);
    if (LogFileHandle != NULL)
		f_sync(LogFileHandle);
    DistributorHandle ReportHandle = ReportAddDistributor("ProtoBuf");
    //CloseLogFile();
    if (ReportHandle == NULL) status |= 0x8;
    status |= ReportFunc(ReportResponseFunc , REPORT_ADD, ReportHandle);
    start_debug_log_request__free_unpacked(request,NULL);
    /*
        #define SYSCTL_CAUSE_HSRVREQ    0x00001000  // Hardware System Service Request
        #define SYSCTL_CAUSE_HIB        0x00000040  // Hibernate reset
        #define SYSCTL_CAUSE_WDOG1      0x00000020  // Watchdog 1 reset
        #define SYSCTL_CAUSE_SW         0x00000010  // Software reset
        #define SYSCTL_CAUSE_WDOG0      0x00000008  // Watchdog 0 reset
        #define SYSCTL_CAUSE_BOR        0x00000004  // Brown-out reset
        #define SYSCTL_CAUSE_POR        0x00000002  // Power on reset
        #define SYSCTL_CAUSE_EXT        0x00000001  // External reset
     */
    ReportResetReason();
    Task_sleep (100);
    ReportEmbeddedVersion();

    usnprintf(SerMessage, 50, "MCU serial %s",Main_EEPROM_Data.bytes.Main_card_SN);
    Report(SerMessage, __FILE__, __LINE__, _gTangoVersion.m_patch, RpWarning, _gTangoVersion.m_build, 0);

    /*SysCtlResetCauseClear(RESC);*/
#ifdef TEST_PID_THREAD
    Task_sleep(1000);
    dyeingspeed = 50;
    ThreadJoggingFunc(50);
    ThreadPreSegmentState(NULL,0);
    Task_sleep(2000);
    ThreadAbortJoggingFunc();
#endif
    return status;
}

uint32_t SetDebugLogCategoryFunc(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;

    SetDebugLogCategoryRequest* request = set_debug_log_category_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    SetDebugLogCategoryResponse response = SET_DEBUG_LOG_CATEGORY_RESPONSE__INIT;
    uint32_t status = ERROR;

    switch(request->minimumcategory)
    {
        case DEBUG_LOG_CATEGORY__Info:
            ReportSeveritySet(RpMessage);
            status = OK;
            break;
        case DEBUG_LOG_CATEGORY__Warning:
            ReportSeveritySet(RpWarning);
            status = OK;
            break;
        case DEBUG_LOG_CATEGORY__Error:
            ReportSeveritySet(RpError);
            status = OK;
            break;
        case DEBUG_LOG_CATEGORY__Critical:
            ReportSeveritySet(RpFatalError);
            status = OK;
            break;
        case DEBUG_LOG_CATEGORY__Debug:
            ReportSeveritySet(RpPrivate);
            status = OK;
            break;
        default:
            break;
    }

    responseContainer = createContainer(MESSAGE_TYPE__SetDebugLogCategoryResponse, requestContainer->token, true, &response, &set_debug_log_category_response__pack, &set_debug_log_category_response__get_packed_size);
    responseContainer.has_continuous = true;
    responseContainer.continuous = false;
    if (status != OK)
    {
        LOG_ERROR(request->minimumcategory,"SetDebugLogCategory failed");
        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
        responseContainer.has_error = true;
    }
    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);
    //USBCDCD_sendData(container_buffer, container_size,10);
    SendChars(container_buffer, container_size);
    //free (container_buffer);

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

    MessageContainer responseContainer;

    StopDebugLogRequest* request = stop_debug_log_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StopDebugLogResponse response = STOP_DEBUG_LOG_RESPONSE__INIT;

//TODO Handle the request!!!!
    ReportStopReporting();
    responseContainer = createContainer(MESSAGE_TYPE__StopDebugLogResponse, protobufToken, false, &response, &stop_debug_log_response__pack, &stop_debug_log_response__get_packed_size);
    responseContainer.has_continuous = true;
    responseContainer.continuous = true;
    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);
    //USBCDCD_sendData(container_buffer, container_size,10);
    SendChars(container_buffer, container_size);
    //free (container_buffer);

return OK;
}
void ReportStopReporting(void)
{
    protobufToken[0] = 0;
    //OpenLogFile();
}


/***************************************************************************
 *
 *  Name        : ReportInit
 *
 *  Function    : PEPORT library init
 *
 *  Notes       : Should be called before any other function from the Report
 *		          package.
 *
 *  Return value: OK or ERROR if malloc has failed or task creation has 
 *                failed
 **************************************************************************/
STATUS ReportInit(ReportInitParams InitParams)
{
    static int initialized = false;
    STATUS status;
    int MaxNumOfFilterNames;

    if (initialized) 
        return OK;

    /* Set the filter to receive all kind */
    ReportSeveritySet(RpMessage);

   /* Configure distributor */
    if( distibutorInit(InitParams.DistributorTaskPriority,
                       InitParams.DistributorQueueMaxMsgs,
                       InitParams.MaxNumberOfPrivateDistributors) == -1)
        return ERROR;

    /* Add the support of the monitor commands */
    //ReportMonitorInit();
    /* Add the Monitor Output routine, by default */
    //ReportMonitorFunc(REPORT_ADD, 0);

    MaxNumOfFilterNames = InitParams.MaxNumOfFilterNames;
    status = filterTableInit(MaxNumOfFilterNames);
    if (status == OK)
        initialized = true;
    ControlFilter  = ReportAddFilterPackage("Control");
    HeatersFilter  = ReportAddFilterPackage("Heaters");
    JobFilter  = ReportAddFilterPackage("Job");
    WasteFilter  = ReportAddFilterPackage("Waste");
    AlarmFilter  = ReportAddFilterPackage("Alarm");
    DiagnosticsFilter  = ReportAddFilterPackage("Diagnost");
    IDSFilter  = ReportAddFilterPackage("IDS");
    ThreadFilter  = ReportAddFilterPackage("Thread");
    GeneralFilter  = ReportAddFilterPackage("General");
    CommFilter  = ReportAddFilterPackage("Comm");
    FPGAFilter  = ReportAddFilterPackage("FPGA");
    LoadFilter  = ReportAddFilterPackage("Load");
    InitFilter  = ReportAddFilterPackage("Init");
    MaintFilter  = ReportAddFilterPackage("Maint");
    IFSFilter  = ReportAddFilterPackage("IFS");
    FilesFilter  = ReportAddFilterPackage("Files");
    I2CFilter  = ReportAddFilterPackage("I2C");
    MotorFilter  = ReportAddFilterPackage("Motor");
//    Filter  = ReportAddFilterPackage("");
    //ReportSwitchPackageFilter(IDSFilter,REPORT_OFF);
    ReportSwitchPackageFilter(WasteFilter,REPORT_OFF);
    return status;
}