Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

13 files changed, 106 insertions, 55 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index c311e9787..d57d3b14b 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -86,7 +86,7 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
         Fresult = FR_DENIED;
     else
     {
-        Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE |  FA_OPEN_ALWAYS );
+        Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE  |FA_OPEN_ALWAYS| FA_CREATE_ALWAYS);
         if (Fresult == FR_OK)
         {
             FileLength = request->length;
diff --git a/Software/Embedded_SW/Embedded/Common/report/distributor.c b/Software/Embedded_SW/Embedded/Common/report/distributor.c
index 0515b0472..c026ad4d2 100644
--- a/Software/Embedded_SW/Embedded/Common/report/distributor.c
+++ b/Software/Embedded_SW/Embedded/Common/report/distributor.c
@@ -242,7 +242,7 @@ Void reportService(UArg arg0, UArg arg1)
     ReportInitParams InitParams;
     InitParams.DistributorQueueMaxMsgs = 30;
     InitParams.DistributorTaskPriority = 6;
-    InitParams.MaxNumOfFilterNames = 1;
+    InitParams.MaxNumOfFilterNames = 1;//30
     InitParams.MaxNumberOfPrivateDistributors = 2;
     ReportInit (InitParams);
 
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index feb13504a..bc3cbe20b 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -38,6 +38,21 @@
 #include "PMR/debugging/StartDebugLogResponse.pb-c.h"
 #include "PMR/debugging/StopDebugLogResponse.pb-c.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;*/
+
 
 char protobufToken[36+1] = {0};
 int ReportResponseFunc(char *message,       /* The formatted message                */
@@ -115,11 +130,6 @@ uint32_t ReportInitMessage(MessageContainer* requestContainer)
 
     StartDebugLogRequest* request = start_debug_log_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (protobufToken, requestContainer->token,36);
- /*   InitParams.DistributorQueueMaxMsgs = 20;
-    InitParams.DistributorTaskPriority = 6;
-    InitParams.MaxNumOfFilterNames = 1;
-    InitParams.MaxNumberOfPrivateDistributors = 2;
-    status |= ReportInit (InitParams);*/
     DistributorHandle ReportHandle = ReportAddDistributor("ProtoBuf");
     if (ReportHandle == NULL) status |= 0x8;
     status |= ReportFunc(ReportResponseFunc , REPORT_ADD, ReportHandle);
@@ -166,7 +176,6 @@ void ReportStopReporting(void)
     protobufToken[0] = 0;
 }
 
-#define REPORT_RESERVED_NUM_OF_FILTER_PACKAGES 30 /* This reserved for swinfra packages */
 
 /***************************************************************************
  *
@@ -204,10 +213,24 @@ STATUS ReportInit(ReportInitParams InitParams)
     //ReportMonitorFunc(REPORT_ADD, 0);
 
     MaxNumOfFilterNames = InitParams.MaxNumOfFilterNames;
-    MaxNumOfFilterNames += REPORT_RESERVED_NUM_OF_FILTER_PACKAGES;
     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("Diagnostics");
+    IDSFilter  = ReportAddFilterPackage("IDS");
+    ThreadFilter  = ReportAddFilterPackage("Thread");
+    GeneralFilter  = ReportAddFilterPackage("General");
+    CommFilter  = ReportAddFilterPackage("Comm");
+    FPGAFilter  = ReportAddFilterPackage("FPGA");
+    LoadFilter  = ReportAddFilterPackage("Load");
+    InitFilter  = ReportAddFilterPackage("Init");
+    MaintFilter  = ReportAddFilterPackage("Maint");*/
+//    Filter  = ReportAddFilterPackage("");
 
     return status;
 }
diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index bb6b82743..ad57c36ab 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -136,7 +136,7 @@ void receive_callback(char* buffer, size_t length)
      DataLength[index] = requestContainer->data.len;
      if (index++>=MAX_CONT_LOG)
          index = 0;
-     REPORT_MSG(requestContainer->type,"Message received");
+     //REPORT_MSG(requestContainer->type,"Message received");
      switch(requestContainer->type)
      {
          case MESSAGE_TYPE__CalculateRequest:
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 66a5aa74f..424eff1d8 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -5,6 +5,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <driverlib/gpio.h>
+#include "common/report/report.h"
 
 //#define EVALUATION_BOARD // to use the LCD only when using the evaluation board
 //#define USE_USB
@@ -399,5 +400,21 @@ Supports diagnostic <id> (--diag_suppress, - pds)
 #define HEAD6_PT100 TEMP_SENSE_AN_ENCLOSURETEMP3
 #define MIXER_PT100 TEMP_SENSE_ANALOG_MIXCHIP_TEMP
 
+/*
+extern PackageHandle ControlFilter;
+extern PackageHandle HeatersFilter;
+extern PackageHandle JobFilter  ;
+extern PackageHandle WasteFilter  ;
+extern PackageHandle AlarmFilter  ;
+extern PackageHandle DiagnosticsFilter;
+extern PackageHandle IDSFilter;
+extern PackageHandle ThreadFilter;
+extern PackageHandle GeneralFilter;
+extern PackageHandle CommFilter;
+extern PackageHandle FPGAFilter;
+extern PackageHandle LoadFilter;
+extern PackageHandle InitFilter;
+extern PackageHandle MaintFilter;
+*/
 
 #endif /* DATADEF_H */
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index cf1e9920c..7efea86f4 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -147,7 +147,7 @@ Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskP
 
 var ProcessTaskParams = new Task.Params();
 ProcessTaskParams.instance.name = "process";
-ProcessTaskParams.stackSize = 2048;
+ProcessTaskParams.stackSize = 4096;
 ProcessTaskParams.priority = 8;
 Program.global.process = Task.create("&jobTask", ProcessTaskParams);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 3826168ec..c936d842c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -67,30 +67,30 @@ int DiagnosticCollectionLimit = 2;  //number of data samples to collect before s
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 
-//DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT];
-double dancer1angle[DIAGNOSTICS_LIMIT];
-double dancer2angle[DIAGNOSTICS_LIMIT];
-double dancer3angle[DIAGNOSTICS_LIMIT];
+//DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
+double dancer1angle[DIAGNOSTICS_LIMIT+1];
+double dancer2angle[DIAGNOSTICS_LIMIT+1];
+double dancer3angle[DIAGNOSTICS_LIMIT+1];
 
-double feedermotorfrequency[DIAGNOSTICS_LIMIT];
-double dryermotor[DIAGNOSTICS_LIMIT];
-double pollermotor[DIAGNOSTICS_LIMIT];
-double windermotor[DIAGNOSTICS_LIMIT];
-double screwmotor[DIAGNOSTICS_LIMIT];
-double mixertemperature[DIAGNOSTICS_LIMIT];
-double headzone1temperature[DIAGNOSTICS_LIMIT];
-double headzone2temperature[DIAGNOSTICS_LIMIT];
-double headzone3temperature[DIAGNOSTICS_LIMIT];
-double headzone4temperature[DIAGNOSTICS_LIMIT];
-double headzone5temperature[DIAGNOSTICS_LIMIT];
-double headzone6temperature[DIAGNOSTICS_LIMIT];
-double dryerzone1temperature[DIAGNOSTICS_LIMIT];
-double dryerzone2temperature[DIAGNOSTICS_LIMIT];
-double dryerzone3temperature[DIAGNOSTICS_LIMIT];
+double feedermotorfrequency[DIAGNOSTICS_LIMIT+1];
+double dryermotor[DIAGNOSTICS_LIMIT+1];
+double pollermotor[DIAGNOSTICS_LIMIT+1];
+double windermotor[DIAGNOSTICS_LIMIT+1];
+double screwmotor[DIAGNOSTICS_LIMIT+1];
+double mixertemperature[DIAGNOSTICS_LIMIT+1];
+double headzone1temperature[DIAGNOSTICS_LIMIT+1];
+double headzone2temperature[DIAGNOSTICS_LIMIT+1];
+double headzone3temperature[DIAGNOSTICS_LIMIT+1];
+double headzone4temperature[DIAGNOSTICS_LIMIT+1];
+double headzone5temperature[DIAGNOSTICS_LIMIT+1];
+double headzone6temperature[DIAGNOSTICS_LIMIT+1];
+double dryerzone1temperature[DIAGNOSTICS_LIMIT+1];
+double dryerzone2temperature[DIAGNOSTICS_LIMIT+1];
+double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];
 
 
-double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT];
-double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT];
+double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
+double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
 
@@ -101,14 +101,14 @@ HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
 DigitalInterfaceState **digitalinterfacestates;
 DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+2];
-/*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser2motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser3motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser4motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser5motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser6motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser7motorfrequency[DIAGNOSTICS_LIMIT];
-double dispenser8motorfrequency[DIAGNOSTICS_LIMIT];
+/*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser4motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser5motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser6motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser7motorfrequency[DIAGNOSTICS_LIMIT+1];
+double dispenser8motorfrequency[DIAGNOSTICS_LIMIT+1];
 */
 Task_Handle Diagnostics_Task_Handle;
 Mailbox_Handle          DiagnosticsMsgQ = NULL;
@@ -183,15 +183,15 @@ void  SetDiagnosticCollectionLimit(int limit)
 }
 
 uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0};
-double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT];
+double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT+1];
 uint8_t  DancerCounterIndex[NUM_OF_DANCERS]= {0,0,0};
-double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT];
+double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
 int8_t  DancerErrorCounterIndex[NUM_OF_DANCERS]= {0,0,0};
-double DancerErrorValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT];
+double DancerErrorValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
 uint8_t  MotorCounterIndex[MAX_THREAD_MOTORS_NUM]= {0,0,0};
-double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT];
+double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT+1];
 uint8_t  SpeedCounterIndex= 0;
-double SpeedValue[DIAGNOSTICS_DANCER_LIMIT];
+double SpeedValue[DIAGNOSTICS_DANCER_LIMIT+1];
 
 void DiagnosticLoadMotor(int MotorId, int frequency)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index bacbe3bfb..74f8c8746 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -58,7 +58,7 @@ uint32_t HWConfigurationInit(void)
     uint8_t* buffer = NULL;
     uint32_t Bytes = 0,i,j,k=0;
     uint32_t status = OK;
-    UploadHardwareConfigurationRequest* UploadRequest;
+    UploadHardwareConfigurationRequest* UploadRequest=0;
 
     GeneralHwReady = false;
     Control_WD(ENABLE,250);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index b9120ddef..8fe9e5c2e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -433,7 +433,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
         //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
         HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
-        Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
+        //Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
     }
@@ -497,7 +497,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
         LOG_ERROR (HeaterId,"PT100 not working properly");
         return ERROR;
     }
-    Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
+    //Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
@@ -658,11 +658,11 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         {
             if (HeaterMaxTempFlag[index] == true)
             {
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+               /* ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                 if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]==false)
                 {
                     ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                }
+                }*/
        //         LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
             }
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c
index 1b6ed8989..c6ea742a7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c
@@ -32,8 +32,15 @@ void Stub_ValveRequest(MessageContainer* requestContainer)
 	request->inkflow
 	request->valveon
     */
-    //Control3WayValvesWithCallback (request->valveid, request->valveon, NULL);
-    //Valve_Set(request->valveid, request->valveon);
+
+    if(request->inkflow == 3)
+    {
+        Control3WayValvesWithCallback (request->valveid, request->valveon, NULL);
+    }
+    else
+    {
+        Valve_Set(request->valveid, request->valveon);
+    }
 
     StubValveResponse response =   STUB_VALVE_RESPONSE__INIT;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index faee55608..d8564963c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -454,7 +454,7 @@ void ScrewTimerInterrupt(int ARG0)
         TimerDisable(Screw_timerBase, TIMER_A);
     }
     ROM_IntMasterEnable();
-    Rotations+=0.1;
+    Rotations+=0.03;
     /*random++;
     if (random >= 2)
         random = -1;*/
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 4131fbca5..9f5ece15a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -751,7 +751,7 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
     //wait for all motors to get to the required speed (set the target speed for the control to check)
     //call the job state machine when the thread system is ready
     if ((InitialProcess==false) && (EnableIntersegment == true) && (IntersegmentLength >= 1.0)) //fix - avoid intersegment length 0
-    {
+    {//add initial presegment and cleaning before first segment
         ThreadUpdateProcessLength (IntersegmentLength,(void *)ThreadInterSegmentEnded);
         REPORT_MSG (IntersegmentLength," ThreadPreSegmentState IntersegmentLength");
     }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index 7c720f848..53057c170 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -158,6 +158,7 @@ uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result)
     if (PreSegmentWaiting[ModuleId] != ModuleWaiting)
     {
         LOG_ERROR (ModuleId, "Message from unrelated module!!");
+        return OK;
     }
 
     PreSegmentWaiting[ModuleId] = result;
@@ -232,11 +233,13 @@ uint32_t SegmentReady(int ModuleId, ModuleStateEnum result)
 
     assert (ModuleId<MAX_SYSTEM_MODULES);
     assert (result<=ModuleFail);
-    LOG_ERROR (ModuleId, "SegmentReady");
+    REPORT_MSG (ModuleId, "SegmentReady");
+    Report("IDSSegmentState",__FILE__,__LINE__,(int)ModuleId,RpWarning,(int)result,0);
 
     if (SegmentWaiting[ModuleId] != ModuleWaiting)
     {
         LOG_ERROR (ModuleId, "Message from unrelated module!!");
+        return OK;
     }
 
     SegmentWaiting[ModuleId] = result;
@@ -307,6 +310,7 @@ uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result)
     if (DistanceToSpoolWaiting[ModuleId] != ModuleWaiting)
     {
         LOG_ERROR (ModuleId, "Message from unrelated module!!");
+        return OK;
     }
 
     DistanceToSpoolWaiting[ModuleId] = result;