aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Embedded_SW/Embedded
diff options
context:
space:
mode:
authorRonen Sberlo <ronen.s@twine-s.com>2020-08-30 11:12:02 +0300
committerRonen Sberlo <ronen.s@twine-s.com>2020-08-30 11:12:02 +0300
commit68d37acbc75ada538965317d71d08cadda350bd2 (patch)
tree8bfc0f75a4d19d8a3dfd0b4174d05142b38246a3 /Software/Embedded_SW/Embedded
parent916b852f7ad8018f883f3ae8a5b119be0cc12883 (diff)
parent67535ff57e1c640382d4e9e38ba636c3c5c3960b (diff)
downloadTango-68d37acbc75ada538965317d71d08cadda350bd2.tar.gz
Tango-68d37acbc75ada538965317d71d08cadda350bd2.zip
Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango
Diffstat (limited to 'Software/Embedded_SW/Embedded')
-rw-r--r--Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c48
-rw-r--r--Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c20
-rw-r--r--Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c62
-rw-r--r--Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c56
-rw-r--r--Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c199
5 files changed, 199 insertions, 186 deletions
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index d9f8d30fd..04e333459 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -64,11 +64,11 @@ uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
{
last = true;
SafeRemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
- Report("MotorHomingProgressReport stopped 1000",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped 1000",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
HomingControlId[deviceID] = 0xff;
}
response.progress = HomingCounter[deviceID]++;
- Report("MotorHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], last, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
responseContainer.has_continuous = true;
responseContainer.continuous = true;
@@ -107,7 +107,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
}
if (HomingControlId[deviceID] != 0xff)
{
- Report("MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
RemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
HomingControlId[deviceID] = 0xff;
}
@@ -177,7 +177,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
{
direction = DRIER_LID_OPEN;
}
- Report("MotorHomingRequestFunc Dryer lid open",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_OPEN,RpMessage,GPI_LS_DRYER_LID_OPEN,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingRequestFunc Dryer lid open",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_OPEN,RpMessage,GPI_LS_DRYER_LID_OPEN,0);
MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,10000);
status = OK;
}
@@ -226,7 +226,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
{
direction = DRIER_LID_CLOSE;
}
- Report("MotorHomingRequestFunc Dryer lid close",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_CLOSE,RpMessage,GPI_LS_DRYER_LID_CLOSED,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingRequestFunc Dryer lid close",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_CLOSE,RpMessage,GPI_LS_DRYER_LID_CLOSED,0);
MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,10000);
status = OK;
}
@@ -260,7 +260,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
{
HomingControlId[MotorId] = AddControlCallback(NULL, MotorHomingProgressReport, 2*eOneSecond, TemplateDataReadCBFunction,MotorId, 0, 0 );
HomingCounter[MotorId] = 0;
- Report("MotorHomingProgressReport started",__FILE__,__LINE__,MotorId,RpMessage,HomingControlId[MotorId],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport started",__FILE__,__LINE__,MotorId,RpMessage,HomingControlId[MotorId],0);
}
else
{
@@ -338,7 +338,7 @@ uint32_t DispenserHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
response.progress = IDS_Dispenser_Data[deviceID].consumedinnanolitter;
responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], last, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
- Report("DispenserHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,IDS_Dispenser_Data[deviceID].consumedinnanolitter,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,IDS_Dispenser_Data[deviceID].consumedinnanolitter,0);
responseContainer.has_continuous = true;
responseContainer.continuous = true;
uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -359,7 +359,7 @@ uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
{
RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
HomingControlId[MotorId] = 0xff;
- Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingControlId[MotorId],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingControlId[MotorId],0);
}
//close dry air valve in the dispenser
@@ -412,7 +412,7 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
if (status == OK)
{
HomingControlId[MotorId] = AddControlCallback(NULL, DispenserHomingProgressReport, 2*eOneSecond, TemplateDataReadCBFunction,request->index, 0, 0 );
- Report("DispenserHomingProgressReport started",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport started",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
}
}
else
@@ -445,7 +445,7 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
{
RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
HomingControlId[MotorId] = 0xff;
- Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+ ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport stopped",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
}
/*
TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
@@ -467,7 +467,7 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
MessageContainer responseContainer;
MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
- Report("Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
//NumberOfDrierLoaderCycles=0;
//storeLoadArmParameters();
@@ -488,13 +488,13 @@ uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadVal
{
D_numberOfCycles++;
uint32_t temp = Read_Dryer_ENC_Position();
- Report("Diagnostics_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
- //Report("Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
+ //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
if ((abs (temp -D_DrierPrevLocation)>1000 )&&(ReadValue == NOTBUSY)) // OK - take another round
// if (ReadValue == NOTBUSY) // OK - take another round
{
D_DrierPrevLocation = temp;
- Report("Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
if (D_numberOfCycles<LoadArmRounds)
{
MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
@@ -505,15 +505,15 @@ uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadVal
{
MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Set_Load_Arm_To_Stopper_Callback,15000,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize);
MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
- Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
}
}
else //timeout or no movement
{
- Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(D_numberOfCycles-2));//it takes two cycles to identify a stop of the arm
- Report("Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
}
return OK;
}
@@ -534,7 +534,7 @@ uint32_t Diagnostics_Dryer_UnLoading(void)
MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
D_DrierPrevLocation = temp;
- Report("Diagnostics_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_DrierPrevLocation,RpMessage, LoadArmRounds,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_DrierPrevLocation,RpMessage, LoadArmRounds,0);
MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
// status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
// MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Diagnostics_Set_Load_Arm_To_Stopper_Callback,0,1000);
@@ -548,7 +548,7 @@ uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint
MessageContainer responseContainer;
MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
- //Report("Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
+ //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[MotorId], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
responseContainer.has_continuous = true;
@@ -566,13 +566,13 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
{
D_numberOfCycles++;
- Report("Diagnostics_Dryer_Loading_Callback",__FILE__,(int)D_numberOfCycles,(int)D_DrierPrevLocation,RpMessage,ReadValue,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,(int)D_numberOfCycles,(int)D_DrierPrevLocation,RpMessage,ReadValue,0);
MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
if (ReadValue == NOTBUSY)
{
- //Report("Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
- //Report("Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+ //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+ //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
if (D_numberOfCycles<LoadArmRounds)
{
MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
@@ -581,12 +581,12 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
else
{
MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Dryer_MovetoEncoderPosition_Callback,15000,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize);
- Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
}
}
else
{
- Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+ ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
}
return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index 09f5ae108..256d25aa5 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -62,25 +62,25 @@ uint32_t IDS_Cleaning_Move_Actuators()
{
Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
//Trigger_Head_Actuators_Control(ACTIN, LOW,true);
- Report("IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning, CleaningStageCounter, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning, CleaningStageCounter, 0);
}
else if (CleaningStageCounter == Tup)
{
Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
//Trigger_Head_Actuators_Disable();
- Report("IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning, CleaningStageCounter, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning, CleaningStageCounter, 0);
}
else if (CleaningStageCounter == Tdelay1)
{
Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
//Trigger_Head_Actuators_Control(ACTIN, LOW,false);
- Report("IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning, CleaningStageCounter, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning, CleaningStageCounter, 0);
}
else if (CleaningStageCounter == Tdelay2)
{
CleaningStageCounter = 0;
Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
- Report("IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning, CleaningStageCounter, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning, CleaningStageCounter, 0);
}
@@ -98,7 +98,7 @@ uint32_t IDS_Cleaning_Move_Actuators()
status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, RightRockerSpeed);
status |= MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize);
status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH, LeftRockerSpeed);
- Report("IDS_Cleaning_Move_Rockers", __FILE__, __LINE__, LeftRockerSpeed, RpWarning, RightRockerSpeed, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_Rockers", __FILE__, __LINE__, LeftRockerSpeed, RpWarning, RightRockerSpeed, 0);
return status;
}
@@ -112,7 +112,7 @@ uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callbac
//Trigger_Head_Actuators_Control(ACTIN, LOW,false);
CleaningStageCounter = 0;
CleaningStage = CleaningStageIdle;
- Report("IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning, 123456, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning, 123456, 0);
return status;
}*/
@@ -124,8 +124,8 @@ uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr
Tdelay2 = RightRockerSpeed;
status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANER_DISPENSER, dispenserSpeed, callback);
Init_CleaningStageCounter();
- Report("IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning, dispenserSpeed, 0);
- Report("IDS_Cleaning parameters", __FILE__, Tup*100, Tdelay1*100, RpWarning, Tdelay2*100, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning, dispenserSpeed, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning parameters", __FILE__, Tup*100, Tdelay1*100, RpWarning, Tdelay2*100, 0);
return status;
@@ -134,11 +134,11 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback)
{
uint32_t status = OK;
status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANER_DISPENSER,callback);
- Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning, status, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning, status, 0);
HeadCard_Actuators_Relocate();
Init_CleaningStageCounter();
CleaningStage = CleaningStageIdle;
- Report("IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning, CleaningStageCounter, 0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning, CleaningStageCounter, 0);
return status;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 7693d1520..3c9e4ef05 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -49,8 +49,8 @@ void IDS_Dispenser_SetPrepareValues( uint32_t DispenserBuildPressureSpeed,
DispenserPreparePressure = DispenserBuildPressureLimit;
DispenserPrepareTimeout = DispenserBuildPressureTimeout;
DispenserPrepareTimeLag = DispenserBuildPressureLag;
- Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)(DispenserPreparePressure*100),0);
- Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareTimeout,RpWarning,(int)DispenserPrepareTimeLag,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)(DispenserPreparePressure*100),0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareTimeout,RpWarning,(int)DispenserPrepareTimeLag,0);
}
void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
{
@@ -59,7 +59,7 @@ void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
CloseValveTimeout = CloseTimeout;
OpenValveTimeout = OpenTimeout;
}
- Report("IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
}
//********************************************************************************************************************
@@ -89,7 +89,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_Build_Pressure_Callback )==OK)
DispenserControlId[DispenserId] = 0xFF;
else
- Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId];
MotorStop(HW_Motor_Id,Hard_Hiz);
CurrentDispenserSpeed[DispenserId] = 0;
@@ -107,19 +107,19 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback)
{
DispenserCallback[DispenserId] = callback;
- Report("IDS_Dispenser_Build_Pressure called ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Build_Pressure called ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0);
Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
if (DispenserControlId[DispenserId] != 0xFF)
{
- Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
}
DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,TemplateDataReadCBFunction ,DispenserId, DispenserId, 0 );
if (DispenserControlId[DispenserId] == 0xFF)
- Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
else
{
- //Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ //ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
DispenserPrepareTime[DispenserId]=0;
TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId];
MotorSetDirection(HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
@@ -132,11 +132,11 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
*/
uint32_t IDS_Dispenser_StopMotorCallback(uint32_t DispenserId, uint32_t ReadValue)
{
- Report("IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_StopMotorCallback )==OK)
DispenserControlId[DispenserId] = 0xFF;
else
- Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId];
MotorStop(HW_Motor_Id,Hard_Hiz);
@@ -153,31 +153,31 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback)
{
DispenserCallback[DispenserId] = callback;
- //Report("IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
if (DispenserControlId[DispenserId] != 0xFF)
- Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
if (DispenserControlId[DispenserId] == 0xFF)
- Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
//else
- // Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ // ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
return OK;
}
uint32_t IDS_Dispenser_OpenValveCallback(uint32_t DispenserId, uint32_t ReadValue)
{
- //Report("IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_OpenValveCallback )==OK)
DispenserControlId[DispenserId] = 0xFF;
else
- Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
- //Report("Control3WayValvesWithCallback called ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0);
+ //ReportWithPackageFilter(IDSFilter,"Control3WayValvesWithCallback called ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0);
Control3WayValvesWithCallback (DispenserId, OpenValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
if (DispenserCallback[DispenserId])
@@ -207,14 +207,14 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
MotorSetSpeed(HW_Motor_Id, MotorSpeed);
CurrentDispenserSpeed[DispenserId] = MotorSpeed;
if (DispenserControlId[DispenserId] != 0xFF)
- Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
- //Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+ ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
if (DispenserControlId[DispenserId] == 0xFF)
- Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
//else
- // Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+ // ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
//}
return OK;
@@ -289,11 +289,11 @@ void IDS_Dispenser_Content_Init (void)
IDS_Dispenser_Data[i].microsteps = StoredDispenserData->dispenserinfo[i]->microsteps;
IDS_Dispenser_Data[i].numberofrefills = StoredDispenserData->dispenserinfo[i]->numberofrefills;
IDS_Dispenser_Data[i].nanolitterperpulse = StoredDispenserData->dispenserinfo[i]->nanolitterperpulse;
- Report("IDS_Dispenser load data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser load data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
}
dispenser_data__free_unpacked(StoredDispenserData,NULL);
}
- //Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
return;
//==================================
@@ -314,11 +314,11 @@ uint32_t IDS_Dispenser_Store_Data (void)
for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
{
StoreDispenserData.dispenserinfo[i] = &IDS_Dispenser_Data[i];
- Report("IDS_Dispenser store data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser store data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
}
-// Report("IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
-// Report("IDS_Dispenser_Store_Data 4",__FILE__,(int)IDS_Dispenser_Data[4].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[4].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[4].microsteps,0);
+// ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
+// ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store_Data 4",__FILE__,(int)IDS_Dispenser_Data[4].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[4].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[4].microsteps,0);
if (JobIsActive()==false)
{
@@ -326,7 +326,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
EraseFlashSection(DISPENSERS_SECTION_FLASH);
ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, dispensers_container_buffer);
- //Report("IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
/*Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
if (Status == FR_OK)
@@ -362,7 +362,7 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
IDS_Dispenser_Data[DispenserId].totalconsumedinnanolitter += (CurrentDispenserSpeed[DispenserId]/10);
if (seconds_counter%1500 == 0) //1500*400MILI = 600000
{
- Report("IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
}
}
if (DispenserId == 0)
@@ -394,7 +394,7 @@ void IDS_Dispenser_RefillStarted (char DispenserId,char MicroSteps)
IDS_Dispenser_Data[DispenserId].nanolitterperpulse = assumedFlow;
IDS_Dispenser_Data[DispenserId].microsteps = 1;
IDS_Dispenser_Data[DispenserId].direction = 0;*/
- Report("IDS_Dispenser_RefillStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_RefillStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
}
void IDS_Dispenser_RefillEnded (char DispenserId,char MicroSteps)
{
@@ -403,7 +403,7 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char MicroSteps)
IDS_Dispenser_Data[DispenserId].numberofrefills++;
//IDS_Dispenser_Data[DispenserId].direction = 1;
IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
- Report("IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
}
void DispenserDataRequestFunc(MessageContainer* requestContainer)
{
@@ -418,7 +418,7 @@ void DispenserDataRequestFunc(MessageContainer* requestContainer)
for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
{
response.dispenserinfo[i] = &IDS_Dispenser_Data[i];
- Report("DispenserDataRequestFunc",__FILE__,__LINE__,(int)response.dispenserinfo[i]->totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,0);
+ ReportWithPackageFilter(IDSFilter,"DispenserDataRequestFunc",__FILE__,__LINE__,(int)response.dispenserinfo[i]->totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,0);
}
responseContainer = createContainer(MESSAGE_TYPE__DispenserDataResponse, requestContainer->token, true, &response, &dispenser_data_response__pack, &dispenser_data_response__get_packed_size);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 14bb59661..663a6713f 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -89,7 +89,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t deviceID);
AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
{
- Report("IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
if (Special_Dispensers == false)
{
AutoHoming_Config = Config;
@@ -110,7 +110,7 @@ void IDS_Dispenser_SetBackLashValues(double initialdispenserpressure, uint32
InitialDispenserTimeLag = initialdispensertimelag;
InitialDispenserSpeed = initialdispenserspeed;
- Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure*100,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure*100,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
}
uint32_t IDS_HomeDispenserWaitForHomingEndCallback(uint32_t DispenserId, uint32_t ReadValue)
{
@@ -173,11 +173,11 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId, uint32_t timeo
Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
Disable_MidTank_Pressure_Reading(DispenserId);
- Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
DispenserHomingControlId[DispenserId] = 0xFF;
else
- Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserHomingControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserHomingControlId[DispenserId],0);
DispenserHomingTime[DispenserId]=0;
}
else
@@ -202,7 +202,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
}
// HomingActive[DispenserId]= false;
IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
- Report("Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
// DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
Task_sleep(10);
@@ -236,25 +236,25 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
double midTankContent = 0.0;
if (FPGA_Read_limit_Switches(Dispenser_Id_to_LS_Id[DispenserId]) == LIMIT)
{
- Report("IDS_HomeDispenser - Disp is full",__FILE__,Dispenser_Id_to_LS_Id[DispenserId],(int)DispenserId,RpWarning,LIMIT,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Disp is full",__FILE__,Dispenser_Id_to_LS_Id[DispenserId],(int)DispenserId,RpWarning,LIMIT,0);
return ERROR;
}
if (Get_MidTank_Pressure_Sensor(DispenserId)<0.2)
{
- Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
return ERROR;
}
midTankContent = Read_MidTank_Pressure_Sensor(DispenserId);
if (midTankContent < 0.2) //midtank is empty - abort!!!!
{
- Report("IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
return ERROR;
}
//if Safety is active
//if safety is upper position or
if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
{
- Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
return ERROR;
}
@@ -262,7 +262,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
{
if ((Get_Notification_Disp_UP(DispenserId) == false)||(Get_Notification_Over_Press(DispenserId) == false))
{
- Report("IDS_HomeDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
Control_TCA9534ByPass(DispenserId,ENABLE);// use ENABLE or DISABLE
}
}
@@ -287,13 +287,13 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
{
MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/4, Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
CurrentDispenserSpeed[DispenserId] = speed/4;
- Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
}
else
{
MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
CurrentDispenserSpeed[DispenserId] = speed;
- Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
}
CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
DispenserLastMovementDown[DispenserId] = true;
@@ -306,10 +306,10 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
{
assert(DispenserId < MAX_SYSTEM_DISPENSERS);
- Report("IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
if ((HomingActive[DispenserId] == false)&&( PrimingActive[DispenserId] == false))
{
- LOG_ERROR (DispenserId,"Homing not active");
+ ReportWithPackageFilter(IDSFilter,"Homing not active",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
return OK;
}
@@ -344,10 +344,10 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
{
assert(DispenserId < MAX_SYSTEM_DISPENSERS);
- Report("IDS_StopHomeDispenser and build pressure",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_StopHomeDispenser and build pressure",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
if (HomingActive[DispenserId] != true)
{
- LOG_ERROR (DispenserId,"Homing not active");
+ ReportWithPackageFilter(IDSFilter,"Homing not active",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
return ERROR;
}
else
@@ -369,10 +369,10 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
HomingRequestCallback[DispenserId] = NULL;
}
// HomingActive[DispenserId]= false;
- Report("End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
/* else
{
- Report("homing aborted,start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"homing aborted,start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
Task_sleep(10);
MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
@@ -421,7 +421,7 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
{
Lubricant_2Way_Valve (STOP);
}
- Report("End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
// MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
if (HomingRequestCallback[DispenserId])
{
@@ -439,14 +439,14 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
// return ERROR;
if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
{
- Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
return ERROR;
}
if (Check_Disp_Safety_Stop_Indication(DispenserId) == true)
{
if ((Get_Notification_Disp_Down(DispenserId) == false)||(Get_Notification_Over_Press(DispenserId) == false))
{
- Report("IDS_EmptyDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_EmptyDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
Control_TCA9534ByPass(DispenserId,ENABLE);// use ENABLE or DISABLE
}
}
@@ -478,7 +478,7 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
{
uint32_t status = OK;
- Report("IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
assert(DispenserId < MAX_SYSTEM_DISPENSERS);
DispensersAlarmState[DispenserId] = true;
TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
@@ -498,12 +498,12 @@ uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
uint32_t status = OK;
assert(DispenserId < MAX_SYSTEM_DISPENSERS);
DispensersAlarmState[DispenserId] = false;
- Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
return status;
}
uint32_t IDS_ReCheck_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
{
- Report("Pulling dispenser down result",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+ ReportWithPackageFilter(IDSFilter,"Pulling dispenser down result",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
SafeRemoveControlCallback(GetControlLowDevice_i(), IDS_ReCheck_Pressure_Callback );
return OK;
@@ -524,7 +524,6 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
{
if (DispenserUsedInJob[DispenserId] == true)
{
- //LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
return ERROR;
}
}
@@ -534,11 +533,10 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
if (GetDispenserPressure(DispenserId)>3.0)
{
//10/8/2020 pulling down 2000 steps
- Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
+ ReportWithPackageFilter(IDSFilter,"Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
{
- Report("Dispenser in pressure but homing active",__FILE__,DispenserId,(int)HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
- LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback homing active");
+ ReportWithPackageFilter(IDSFilter,"Dispenser in pressure but homing active",__FILE__,DispenserId,(int)HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
return ERROR;
}
MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,2000*MotorsCfg[HW_Motor_Id].microstep);
@@ -559,7 +557,7 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
void IDS_Dispenser_Init(uint8_t DispenserId)
{
assert(DispenserId < MAX_SYSTEM_DISPENSERS);
- Report("IDS_Dispenser_Init",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Init",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
CurrentDispenserSpeed[DispenserId] = 0;
HomingActive[DispenserId]= false;
PrimingActive[DispenserId]= false;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index c0ccefde1..8ee0b507e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -103,7 +103,7 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment;
if (dispenserpresegmentwfcf)
WFCF = dispenserpresegmentwfcf;
- Report("IDS_Dispenser_SetPreSegmentWFCFValues ",__FILE__,__LINE__,dispenserpresegmentwfcf,RpWarning,(int)ids_presegment_wfcf_timebeforesegment,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentWFCFValues ",__FILE__,__LINE__,dispenserpresegmentwfcf,RpWarning,(int)ids_presegment_wfcf_timebeforesegment,0);
}
void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed)
@@ -122,9 +122,9 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
if ( ids_rightcleaningmotorspeed)
RightRockerSpeed = ids_rightcleaningmotorspeed;
minimal_intersegment_length = ids_cleaningstopbeforesegmenttime+ids_cleaningstartspraypresegmenttime+2000;
- Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,RightRockerSpeed,RpWarning,(int)LeftRockerSpeed,0);
- Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,minimal_intersegment_length,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
- Report("IDS_Dispenser actuator times ",__FILE__,(int)LeftRockerSpeed/100*IDS_PRESEGMENT_TIME_STEP,(int)LeftRockerSpeed%100*IDS_PRESEGMENT_TIME_STEP,RpWarning,(int)RightRockerSpeed*IDS_PRESEGMENT_TIME_STEP,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,RightRockerSpeed,RpWarning,(int)LeftRockerSpeed,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,minimal_intersegment_length,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Dispenser actuator times ",__FILE__,(int)LeftRockerSpeed/100*IDS_PRESEGMENT_TIME_STEP,(int)LeftRockerSpeed%100*IDS_PRESEGMENT_TIME_STEP,RpWarning,(int)RightRockerSpeed*IDS_PRESEGMENT_TIME_STEP,0);
}
uint32_t DispenserPreSegmentControlId = 0xFF;
@@ -189,21 +189,21 @@ uint32_t IDS_Pid_Testing_Func(uint32_t DispenserId, uint32_t ReadValue)
&DispenserControlConfig[DispenserId].m_params, &DispenserControlConfig[DispenserId].m_preError, &DispenserControlConfig[DispenserId].m_integral);
DispenserControlConfig[DispenserId].m_calculatedError = (-1*DispenserControlConfig[DispenserId].m_calculatedError);
calculated_speed = (1-DispenserControlConfig[DispenserId].m_calculatedError)*CurrentDispenserSpeed[DispenserId];
- Report("IDS_Pid_Testing_Func ",__FILE__,DispenserId,(int)(DispenserControlConfig[DispenserId].m_mesuredParam*1000),RpWarning,(int)calculated_speed,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Pid_Testing_Func ",__FILE__,DispenserId,(int)(DispenserControlConfig[DispenserId].m_mesuredParam*1000),RpWarning,(int)calculated_speed,0);
return OK;
}
void IDS_Start_Pid_Testing(int DispenserId)
{
DispenserPidControlId[DispenserId] = AddControlCallback(NULL, IDS_Pid_Testing_Func,eOneSecond , TemplateDataReadCBFunction,DispenserId,DispenserId, DispenserId );
- Report("IDS_Start_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Start_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
}
void IDS_Stop_Pid_Testing(int DispenserId)
{
//stop this control loop
RemoveControlCallback(DispenserPidControlId[DispenserId], IDS_Pid_Testing_Func );
DispenserPidControlId[DispenserId] = 0xFF;
- Report("IDS_Stop_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Stop_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
}
/*
* IDS Printing support
@@ -291,7 +291,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
if ((brushCounter % 1000)==900)
{
Task_sleep(200);
- Report("Sleep in file parsing",__FILE__, BrushStop->index, brushCounter, RpWarning, Segment->brushstopscount, 0);
+ ReportWithPackageFilter(IDSFilter,"Sleep in file parsing",__FILE__, BrushStop->index, brushCounter, RpWarning, Segment->brushstopscount, 0);
Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds
}
brushCounter++;
@@ -329,7 +329,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
}//if dispensers
else
{
- LOG_ERROR (BrushStop->index, "no dispensers in brushstop");
+ ReportWithPackageFilter(IDSFilter,"no dispensers in brushstop",__FILE__,__LINE__,(int)BrushStop->index,RpError,(int)BrushStop->n_dispensers,0);
}
if (FirstBrushStop!= BrushStop)
FreeBrushStopFileData(BrushStop);
@@ -337,7 +337,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
}
else
{
- LOG_ERROR (BrushStop, "malloc error");
+ ReportWithPackageFilter(IDSFilter,"malloc error",__FILE__,__LINE__,(int)0,RpError,(int)0,0);
status = ERROR;
}
}//for brushstops
@@ -357,7 +357,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
ActiveDispensers++;
}
}
- Report("Finished checking the file", __FILE__, __LINE__, n_segments, RpWarning, ActiveDispensers, 0);
+ ReportWithPackageFilter(IDSFilter,"Finished checking the file", __FILE__, __LINE__, n_segments, RpWarning, ActiveDispensers, 0);
return status;
}
@@ -462,12 +462,12 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
{
if ((HomingActive[DispenserId] == false)&&(PrimingActive[DispenserId] == false))
{
- Report("Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
IDS_HomeDispenser (DispenserId, 1000 , NULL);
}
else
{
- Report("Inactive dispenser already homing",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+ ReportWithPackageFilter(IDSFilter,"Inactive dispenser already homing",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
}
}
return OK;
@@ -490,7 +490,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
{
if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
{
- Report("Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+ ReportWithPackageFilter(IDSFilter,"Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
Control3WayValvesWithCallback (i, MidTank_Dispenser, InactiveDispenserHome); //direction: MidTank_Dispenser or Dispenser_Mixer
}
}
@@ -560,13 +560,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
#endif
{
NumofReadyDispensers++;
- Report("Dispenser total prepare steps ready",__FILE__,DispenserTotalPrepareSteps[i],(int)(DispenserPreparePressure*100),RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
+ ReportWithPackageFilter(IDSFilter,"Dispenser total prepare steps ready",__FILE__,DispenserTotalPrepareSteps[i],(int)(DispenserPreparePressure*100),RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
}
if (Special_Dispensers == true)
{
MotorStop(HW_Motor_Id, Hard_Hiz);
CurrentDispenserSpeed[i] = 0;
- //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
}
else
{
@@ -574,7 +574,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
MotorSetSpeed(HW_Motor_Id, updatedSpeed);
CurrentDispenserSpeed[i] = updatedSpeed;
- //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
}
}
else
@@ -600,31 +600,31 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
MotorStop(HW_Motor_Id, Hard_Hiz);
if (CurrentDispenserSpeed[CLEANER_DISPENSER])
- Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+ ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
}
if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
{
- Report("IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
}
if (NumofReadyDispensers>=NumOfActiveDispensers)
{
pressureReady = true;
- Report("pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
}
if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
{
DispenserBuildTimeCounter = 0;
pressureReady = true;
- Report("pressureReady = true or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
+ ReportWithPackageFilter(IDSFilter,"pressureReady = true or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
}
}
else if (endOfPrepareWCF == false)
{
if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
{
- Report("start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
if (FirstBrushStop)
{
REPORT_MSG(FirstBrushStop->index,"WFCFBrushStopRead Index");
@@ -673,7 +673,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
}
CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
- usnprintf(IdMessage, 80,
+ /*usnprintf(IdMessage, 80,
"WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
DispenserId,
(int) Dispensers[Dispenser_i]->nanolitterpersecond,
@@ -681,8 +681,8 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
(int) Dispensers[Dispenser_i]->pulsepersecond*1000,
(int) segmentfirst_speed*1000);
//REPORT_MSG(segmentfirst_speed,IdsMessage);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
- //SendJobProgress(0.0, 0, false, IdsMessage);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+ //SendJobProgress(0.0, 0, false, IdsMessage);*/
}
else
{
@@ -690,11 +690,15 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
{
MotorStop(HW_Motor_Id, Hard_Hiz);
CurrentDispenserSpeed[Dispenser_i] = 0;
- usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+ //usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+ //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
}
}
}//for
+ usnprintf(IdMessage, 80,"WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+ CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning, WFCF, 0);
+
}//if n_dis
}
}
@@ -708,7 +712,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
endOfPrepareWCF = true;
FreeBrushStopFileData(FirstBrushStop);
FirstBrushStop =NULL;
- Report("endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
}
}
@@ -720,11 +724,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
MotorStop(HW_Motor_Id, Hard_Hiz);
CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
- Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+ ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
}
SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
DispenserPrepareControlId = 0xFF;
- Report("IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
setRapidPressureRead(false);
pressureReady = false;
endOfPrepareWCF = false;
@@ -749,7 +753,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
JobEndSequence = false;
if ((pressurebuildup>0.1)&&(pressurebuildup<4.0))
{
- Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
+ ReportWithPackageFilter(IDSFilter,"Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
DispenserPreparePressure = pressurebuildup;
}
if (JobTicket->headcleaningparameters)
@@ -759,7 +763,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
}
if ((cleanerFlow>200)&&(cleanerFlow<1150))
{
- Report("Setting cleanerFlow from RML cleanerFlow",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
+ ReportWithPackageFilter(IDSFilter,"Setting cleanerFlow from RML cleanerFlow",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
CleaningDispenserSpeed = cleanerFlow;
}
else if (cleanerFlow <= 10)
@@ -811,7 +815,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
if (IDS_Active == false)
{
- LOG_ERROR(IDS_Active,"IDSPrepareStart Not in a job");
+ ReportWithPackageFilter(IDSFilter,"IDSPrepareStart Not in a job",__FILE__,__LINE__,(int)0,RpError,(int)0,0);
return;
}
@@ -827,11 +831,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
NumOfActiveDispensers++;
if (HomingActive[i] == true)
{
- Report("Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
+ ReportWithPackageFilter(IDSFilter,"Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
IDS_StopHomeDispenser(i);
}
DispenserTotalPrepareSteps[i] = 0;
- Report("Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
+ ReportWithPackageFilter(IDSFilter,"Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
}
else
{
@@ -839,12 +843,12 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
{
if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
{
- Report("Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+ ReportWithPackageFilter(IDSFilter,"Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
IDS_HomeDispenser (i, 1000 , NULL);
}
else
{
- Report("Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+ ReportWithPackageFilter(IDSFilter,"Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
}
}
}
@@ -865,7 +869,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
{
//if (HomingActive[i] == false)
{
- Report("Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
+ ReportWithPackageFilter(IDSFilter,"Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
if (Special_Dispensers == true)
{
@@ -878,7 +882,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
}
/*else
{
- Report("IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
+ ReportWithPackageFilter(IDSFilter,"IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
IDS_HomeDispenserWaitForHomingEnd(i, DispenserPrepareTimeout/2 , IDSPrepareStartDispenserAfterHoming);
}*/
}
@@ -886,7 +890,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
- Report("IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+ ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
}
@@ -939,7 +943,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
MotorSetSpeed(HW_Motor_Id, updatedSpeed);
CurrentDispenserSpeed[i] = updatedSpeed;
- //Report("IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
}
else
{
@@ -947,20 +951,20 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
updatedSpeed = (tempSpeed*1.04<1100)?tempSpeed*1.04:1100;
MotorSetSpeed(HW_Motor_Id, updatedSpeed);
CurrentDispenserSpeed[i] = updatedSpeed;
- //Report("IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
}
}
}
if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
- Report("IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
if (NumofReadyDispensers>=NumOfActiveDispensers)
pressureReady = true;
if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
{
- Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
DispenserPrepareControlId = 0xFF;
PreSegmentWCFStarted = true;
@@ -983,7 +987,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
}
if (FileBrushStop)
{
- Report("start dispensers pre segment pressure build",__FILE__,__LINE__,FileBrushStop->index,RpWarning,(int)FileBrushStop->n_dispensers,0);
+ ReportWithPackageFilter(IDSFilter,"start dispensers pre segment pressure build",__FILE__,__LINE__,FileBrushStop->index,RpWarning,(int)FileBrushStop->n_dispensers,0);
NumOfActiveDispensers = FileBrushStop->n_dispensers;
Dispensers = FileBrushStop->dispensers;
n_dispensers = FileBrushStop->n_dispensers;
@@ -1008,9 +1012,9 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
DispenserUsedInSegment[Dispenser_i] = true;
MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
CurrentDispenserSpeed[Dispenser_i] = DispenserPrepareSpeed;
- usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
+ //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
//REPORT_MSG(segmentfirst_speed,IdsMessage);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, DispenserPrepareSpeed, 0);
+ //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, DispenserPrepareSpeed, 0);
//SendJobProgress(0.0, 0, false, IdsMessage);
}
else
@@ -1026,11 +1030,15 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
MotorStop(HW_Motor_Id, Hard_Hiz);
}
CurrentDispenserSpeed[Dispenser_i] = 0;
- usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+ //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+ //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
}
}
- }
+ }//for
+ usnprintf(IdMessage, 80,"Presegment Prepare D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",CurrentDispenserSpeed[0],
+ CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+
DispenserBuildTimeCounter = 0;
//DispenserPrepareControlId = AddControlCallback( IDS_PreSegmentPrepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
setRapidPressureRead(true);
@@ -1112,7 +1120,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
if (InterSegmentStepsCount >= lInterSegmentLength)
{
//IDS_Valve_PresegmentReady(1,0);
- Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
//PreSegmentReady(Module_IDS,ModuleDone);
SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner);
if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
@@ -1125,12 +1133,12 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
{
if (( InterSegmentStartSprayCleaner )&&(InterSegmentStartSprayCleaner == InterSegmentStepsCount))
{
- Report("Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
IDS_Cleaning_Spray_Cleaning_Solution (CleaningDispenserSpeed,NULL);
}
/*if (InterSegmentStartRocking == InterSegmentStepsCount)
{
- Report("Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
//IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
}*/
if (( InterSegmentStartSprayCleaner )&&
@@ -1141,7 +1149,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
}
if (( InterSegmentCenterRockers)&&(InterSegmentCenterRockers == (lInterSegmentLength-InterSegmentStepsCount)))
{
- Report("Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
IDS_Cleaning_Stop_Cleaning_Solution (NULL);
//IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
}
@@ -1163,7 +1171,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
}
if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == InterSegmentStepsCount))
{
- Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
PreSegmentWCFStarted = true; // stop any presegment prepare stages, if still exist
PreSegmentPrepareStarted = false;
setRapidPressureRead(false);
@@ -1210,7 +1218,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
- usnprintf(IdMessage, 80,
+ /*usnprintf(IdMessage, 80,
"WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
DispenserId,
(int) Dispensers[Dispenser_i]->nanolitterpersecond,
@@ -1218,10 +1226,13 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
(int) Dispensers[Dispenser_i]->pulsepersecond*1000,
(int) segmentfirst_speed*1000);
//REPORT_MSG(segmentfirst_speed,IdsMessage);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
- //SendJobProgress(0.0, 0, false, IdsMessage);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+ //SendJobProgress(0.0, 0, false, IdsMessage);*/
}
- }
+ }//for
+ usnprintf(IdMessage, 80,"Presegment WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+ CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning, lInterSegmentLength, 0);
}
}
//startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed);
@@ -1248,7 +1259,7 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
{
if (JobBrushStopId<PrevSegment->brushstopscount) //we did not finish reading the brushstops of the previous segment
{
- Report("Unhandled brushstops remained",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)PrevSegment->brushstopscount,0);
+ ReportWithPackageFilter(IDSFilter,"Unhandled brushstops remained",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)PrevSegment->brushstopscount,0);
//REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
//for (Brush_i=JobBrushStopId;Brush_i<PrevSegment->brushstopscount;Brush_i++) #bug 3348 - unhandled jobstops stops too soon
for (Brush_i=JobBrushStopId;Brush_i<PrevSegment->brushstopscount;Brush_i++)
@@ -1259,22 +1270,22 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
if (tFileBrushStop)
{
FreeBrushStopFileData(tFileBrushStop);
- Report("Unhandled brushstops handled",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+ ReportWithPackageFilter(IDSFilter,"Unhandled brushstops handled",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
}
else
{
Task_stat(Task_self(),&statbuf);
- Report("Unhandled BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+ ReportWithPackageFilter(IDSFilter,"Unhandled BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
//JobEndReason = JOB_OUT_OF_DYE;
//SegmentReady(Module_IDS,ModuleFail);
- Report("Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
+ ReportWithPackageFilter(IDSFilter,"Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
status = ERROR;
break;
}
}//for brushstops
}
}
- Report("Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+ ReportWithPackageFilter(IDSFilter,"Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
return OK;
}
uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
@@ -1294,7 +1305,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
REPORT_MSG(Segment->n_brushstops,"IDSPreSegmentState");
if (JobBrushStopId>=Segment->n_brushstops)
{
- LOG_ERROR(Segment->n_brushstops,"Error JobBrushStopId");
+ ReportWithPackageFilter(IDSFilter,"Error JobBrushStopId",__FILE__,__LINE__,(int)Segment->n_brushstops,RpError,(int)0,0);
JobEndReason = JOB_OUT_OF_DYE;
PreSegmentReady(Module_IDS,ModuleFail);
return ERROR;
@@ -1318,10 +1329,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
DispenserPreSegmentControlId = AddControlCallback(NULL,IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
if (DispenserPreSegmentControlId == 0xFF)
{
- Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
return ERROR;
}
- Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
}
/*if (EnableCleaning == true)
{
@@ -1352,10 +1363,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
if (DispenserPreSegmentControlId == 0xFF)
{
- Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
return ERROR;
}
- Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
if (EnableCleaning == true)
{
InterSegmentStartSprayCleaner = 500;
@@ -1386,7 +1397,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
}
else
{
- LOG_ERROR(FileBrushStop,"End run - BrushStopReadError");
+ ReportWithPackageFilter(IDSFilter,"End run - BrushStopReadError",__FILE__,__LINE__,(int)FileBrushStop,RpError,(int)0,0);
JobEndReason = JOB_OUT_OF_DYE;
PreSegmentReady(Module_IDS,ModuleFail);
}
@@ -1468,7 +1479,7 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers)
int Dispenser_i,DispenserId;
TimerMotors_t HW_Motor_Id;
double segmentfirst_speed;
- Report("IDS_StartBrushStop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)0,0);
+ //ReportWithPackageFilter(IDSFilter,"IDS_StartBrushStop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)0,0);
if (n_dispensers)
{
@@ -1513,7 +1524,7 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers)
MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
}
CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
- usnprintf(IdsMessage, 80,
+ /*usnprintf(IdsMessage, 80,
"Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
DispenserId,
(int) Dispensers[Dispenser_i]->nanolitterpersecond,
@@ -1521,8 +1532,8 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers)
(int) Dispensers[Dispenser_i]->pulsepersecond*1000,
(int) (segmentfirst_speed*1000),Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
//REPORT_MSG(segmentfirst_speed,IdsMessage);
- Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
- //SendJobProgress(0.0, 0, false, IdsMessage);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0);
+ //SendJobProgress(0.0, 0, false, IdsMessage);*/
}
else
{
@@ -1540,10 +1551,14 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers)
}
CurrentDispenserSpeed[DispenserId] = 0;
}
- //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning, segmentfirst_speed, 0);
+ //ReportWithPackageFilter(IDSFilter,"inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning, segmentfirst_speed, 0);
}
- }
+ } //for
}
+ usnprintf(IdMessage, 80,"IDS_StartBrushStop %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+ CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+ ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,n_dispensers, 0);
+
}
uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
{
@@ -1553,7 +1568,7 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
Task_Stat statbuf;
if(BrushStopStartTime+BrushStopLength+100 < msec_millisecondCounter )
{
- Report("!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+ ReportWithPackageFilter(IDSFilter,"!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
}
if(++BrushStopCounter < BrushStopTime)
@@ -1565,13 +1580,13 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
if (BrushStopControlId == 0xFF)
{
- Report("!!!BrushStopControlId = 0xFF",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+ ReportWithPackageFilter(IDSFilter,"!!!BrushStopControlId = 0xFF",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
return OK;
}
if (JobEndSequence == true)
{
- Report("JobEndSequence",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+ ReportWithPackageFilter(IDSFilter,"JobEndSequence",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
SafeRemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
BrushStopControlId = 0Xff;
return OK;
@@ -1590,14 +1605,14 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
{
Task_stat(Control_Task_Handle,&statbuf);
//REPORT_MSG(FileBrushStop->index,"BrushStopRead Index");
- Report("BrushStopRead Index",__FILE__,BrushStopTime,(int)FileBrushStop->index,RpWarning,(int)BrushStopStartTime,0);
+ //ReportWithPackageFilter(IDSFilter,"BrushStopRead Index",__FILE__,BrushStopTime,(int)FileBrushStop->index,RpWarning,(int)BrushStopStartTime,0);
Dispensers = FileBrushStop->dispensers;
n_dispensers = FileBrushStop->n_dispensers;
}
else
{
Task_stat(Task_self(),&statbuf);
- Report("BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+ ReportWithPackageFilter(IDSFilter,"BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
JobEndReason = JOB_OUT_OF_DYE;
SegmentReady(Module_IDS,ModuleFail);
}
@@ -1607,10 +1622,10 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
IDS_StartBrushStop(n_dispensers, Dispensers);
}
JobBrushStopId++;
- Report("brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+ ReportWithPackageFilter(IDSFilter,"brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpMessage,(int)SegmentNumOfBrushStops,0);
if (JobBrushStopId >= SegmentNumOfBrushStops)
{
- Report("last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+ ReportWithPackageFilter(IDSFilter,"last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
SafeRemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
BrushStopControlId = 0Xff;
}
@@ -1624,7 +1639,7 @@ uint32_t IDSSegmentStateSetValve(uint32_t IfIndex, uint32_t BusyFlag)
{
SafeRemoveControlCallback(IDSValveControlId,IDSSegmentStateSetValve);
Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
- Report("IDSSegmentState set valve after 1 second",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
+ ReportWithPackageFilter(IDSFilter,"IDSSegmentState set valve after 1 second",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
return OK;
}
#endif
@@ -1646,7 +1661,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops; //brushstop in meters //brushstop in millisecond
BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
//BrushStopTime *= 1000;
- Report("IDSSegmentState bss time, num of bss",__FILE__,__LINE__,(int)(BrushStopTime),RpWarning,(int)SegmentNumOfBrushStops,0);
+ ReportWithPackageFilter(IDSFilter,"IDSSegmentState bss time, num of bss",__FILE__,__LINE__,(int)(BrushStopTime),RpWarning,(int)SegmentNumOfBrushStops,0);
if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default)
{
Dispensers = Segment->brushstops[JobBrushStopId]->dispensers;
@@ -1661,13 +1676,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
}
else
{
- LOG_ERROR(FileBrushStop,"BrushStopReadError");
+ ReportWithPackageFilter(IDSFilter,"BrushStopRead Error",__FILE__,__LINE__,(int)FileBrushStop,RpError,(int)0,0);
}
}
//handle ending of presegment
if (DispenserPreSegmentControlId != 0xFF)
{
- Report("IDS presegment not yet ended!!",__FILE__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"IDS presegment not yet ended!!",__FILE__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
DispenserPreSegmentControlId = 0xFF;
}
@@ -1682,10 +1697,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
BrushStopLength = BrushStopTime;
if (BrushStopControlId == 0xFF)
{
- Report("Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
return ERROR;
}
- Report("Add control callback ",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)n_dispensers,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)n_dispensers,0);
}
else
@@ -1761,10 +1776,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
DispenserPreSegmentControlId = AddControlCallback("IDS DTS", IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
if (DispenserPreSegmentControlId == 0xFF)
{
- Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
return ERROR;
}
- Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
+ ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
/*if (EnableCleaning == true)
{
InterSegmentStartSprayCleaner = 500;
@@ -1784,7 +1799,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
//MotorStop(HW_Motor_Id,Hard_Hiz);
if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
{
- Report("IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
+ ReportWithPackageFilter(IDSFilter,"IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
if (deviceID!=LUBRICANT_DISPENSER)
IDS_HomeDispenser (deviceID, 1000 , NULL);