updating : special dispensers handling (for Moti), new process parameters, bugs and features. merged with Shai

3 files changed, 96 insertions, 12 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index a183ec996..1984420f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -25,8 +25,8 @@
 #define CloseValve MidTank_Dispenser
 #define OpenValve Dispenser_Mixer
 
-uint32_t CloseValveTimeout = 250;
-uint32_t OpenValveTimeout = 250;
+uint32_t CloseValveTimeout = 10;
+uint32_t OpenValveTimeout = 10;
 #define DISPENSER_BUILD_PRESSURE_SPEED 900
 #define DISPENSER_BUILD_PRESSURE_LIMIT 1.5
 #define DISPENSER_BUILD_PRESSURE_TIMEOUT 60000
@@ -54,8 +54,10 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 {
+#ifndef SPECIAL_DISPENSERS
      CloseValveTimeout = CloseTimeout;
      OpenValveTimeout = OpenTimeout;
+#endif
      Report("IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
 }
 
@@ -249,10 +251,16 @@ void IDS_Dispenser_Content_Init (void)
     memcpy(&Bytes,(void *)DISPENSERS_MAP_IN_FLASH,sizeof(Bytes));
     bool havedata = false;
     DispenserData* StoredDispenserData;
-    if ((Bytes)&&(Bytes < 4000))
+    if ((Bytes)&&(Bytes < 500))
     {
-        StoredDispenserData = dispenser_data__unpack(NULL,Bytes,(DISPENSERS_MAP_IN_FLASH+4));
-        havedata = true;
+        buffer = my_malloc (Bytes);
+        if (buffer)
+        {
+            memcpy(buffer, (void *)(DISPENSERS_MAP_IN_FLASH+4),Bytes);
+            StoredDispenserData = dispenser_data__unpack(NULL,Bytes,buffer);
+            havedata = true;
+            free(buffer);
+        }
     }
     /*else
     {
@@ -267,18 +275,25 @@ void IDS_Dispenser_Content_Init (void)
     {
         for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
         {
-            memcpy (&IDS_Dispenser_Data[i],&StoredDispenserData->dispenserinfo[i],sizeof(DispenserRunningData));
+            //memcpy (&IDS_Dispenser_Data[i],&StoredDispenserData->dispenserinfo[i],sizeof(DispenserRunningData));
             IDS_Dispenser_Data[i].has_consumedinnanolitter = true;
             IDS_Dispenser_Data[i].has_totalconsumedinnanolitter = true;
             IDS_Dispenser_Data[i].has_direction = true;
             IDS_Dispenser_Data[i].has_microsteps = true;
             IDS_Dispenser_Data[i].has_numberofrefills = true;
             IDS_Dispenser_Data[i].has_nanolitterperpulse = true;
+            IDS_Dispenser_Data[i].consumedinnanolitter = StoredDispenserData->dispenserinfo[i]->consumedinnanolitter;
+            IDS_Dispenser_Data[i].totalconsumedinnanolitter = StoredDispenserData->dispenserinfo[i]->totalconsumedinnanolitter;
+            IDS_Dispenser_Data[i].direction = StoredDispenserData->dispenserinfo[i]->direction;
+            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);
         }
         dispenser_data__free_unpacked(StoredDispenserData,NULL);
         free (buffer);
     }
-    Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
+    //Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
     return;
 
     //==================================
@@ -299,6 +314,7 @@ 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);
     }
 
 //    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);
@@ -310,7 +326,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
         EraseFlashSection(DISPENSERS_MAP_IN_FLASH,response_size+4);
         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);
+        //Report("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)
@@ -350,7 +366,7 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
     }
     if (DispenserId == 0)
     {
-        if ((seconds_counter++>=90000)&&(DispenserDataUpdated == true))//90000)// - one hour)
+        if ((seconds_counter++>=900)&&(DispenserDataUpdated == true))//9000)// - one hour)
         {
             seconds_counter = 0;
             if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 41452cbad..1ea37a07e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -489,6 +489,12 @@ uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
     Report("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);
+    SafeRemoveControlCallback(GetControlLowDevice_i(), IDS_ReCheck_Pressure_Callback );
+
+}
 uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 {
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
@@ -510,6 +516,7 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     {
         Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
         MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200*MotorsCfg[HW_Motor_Id].microstep);
+        AddControlCallback("IDS_ReCheck_Pressure", IDS_ReCheck_Pressure_Callback, eOneSecond*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
     }
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 05676dd9e..ad9d75941 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -497,11 +497,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
      if (pressureReady == false)
      {
+#ifndef SPECIAL_DISPENSERS
          if (DispenserBuildTimeCounter<(2*eOneSecond))
          {
              //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
              return OK;
          }
+#endif
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              //IDS_StopHomeDispenser(i);
@@ -511,19 +513,33 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  if (GetDispenserPressure(i) > DispenserPreparePressure)
                  {
                      NumofReadyDispensers++;
+                     CurrentDispenserSpeed[i] = 0;
+#ifdef SPECIAL_DISPENSERS
+                     MotorStop(HW_Motor_Id, Hard_Hiz);
+                     //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
+#else
                      tempSpeed = CurrentDispenserSpeed[i];
                      updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
                      //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+#endif
                  }
                  else
                  {
+#ifdef SPECIAL_DISPENSERS
+                     tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
+                     if (tempSpeed<300)
+                         tempSpeed = 300;
+#else
                      tempSpeed = CurrentDispenserSpeed[i];
+#endif
                      updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
+#ifdef SPECIAL_DISPENSERS
                      //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+#endif
                  }
              }
          }
@@ -544,6 +560,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
      }
+#ifndef SPECIAL_DISPENSERS
      else if (endOfPrepareWCF == false)
      {
          if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
@@ -631,8 +648,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
          }
      }
-         //start new stage
+#endif
+#ifdef SPECIAL_DISPENSERS
+     if (pressureReady == true)
+#else
+     //start new stage
      if (endOfPrepareWCF == true)
+#endif
      {
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
@@ -762,7 +784,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      Report("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
+#ifdef SPECIAL_DISPENSERS
+                     MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
+#else
                      IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
+#endif
                  }
                  /*else
                  {
@@ -899,7 +925,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      if (DispenserUsedInJob[DispenserId] == true)
                      {
+#ifdef SPECIAL_DISPENSERS
+                         IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                          MotorStop(HW_Motor_Id, Hard_Hiz);
+#endif
                          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);
@@ -1019,7 +1049,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //cleaning
          return OK;
      }
-
+#ifndef SPECIAL_DISPENSERS
      if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
      {
 	 	//start prepare 4 seconds before wcf
@@ -1100,6 +1130,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //close waste valve one second before segment - trial
          Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
      }
+#endif
      return OK;
  }
 uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
@@ -1177,7 +1208,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
                 return ERROR;
             }
-            Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0);
+            Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
             /*if (EnableCleaning == true)
             {
                 InterSegmentStartSprayCleaner = 500;
@@ -1285,7 +1316,11 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
+#ifdef SPECIAL_DISPENSERS
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                     MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
+#endif
                     CurrentDispenserSpeed[DispenserId] = 0;
                     //MotorSetSpeed(HW_Motor_Id, 5);
                     //CurrentDispenserSpeed[Dispenser_i] = 5;
@@ -1351,7 +1386,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                                                          segmentfirst_speed,
                                                          NULL);*/
                 //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#ifdef SPECIAL_DISPENSERS
+                IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
+#else
                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+#endif
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
                           "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
@@ -1370,7 +1409,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
+#ifdef SPECIAL_DISPENSERS
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                     MotorStop(HW_Motor_Id, Hard_Hiz);
+#endif
                     CurrentDispenserSpeed[DispenserId] = 0;
                 }
                 //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
@@ -1481,6 +1524,14 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              LOG_ERROR(FileBrushStop,"BrushStopReadError");
          }
      }
+//handle ending of presegment
+    if (DispenserPreSegmentControlId != 0xFF)
+    {
+        Report("IDS presegment not yet ended!!",__FILE__,__LINE__,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+        IDS_Cleaning_Stop_Cleaning_Solution (NULL);
+        RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
+        DispenserPreSegmentControlId = 0xFF;
+    }
 
     IDS_StartBrushStop(n_dispensers, Dispensers);
     JobBrushStopId++;
@@ -1544,7 +1595,11 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              if (DispenserUsedInJob[Dispenser_i]==false)//unconfigured dispenser
                  continue;
              DispenserDistanceToSpoolReady[Dispenser_i] = false;
+#ifdef SPECIAL_DISPENSERS
+             IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+#else
              MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+#endif
              Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
              CurrentDispenserSpeed[Dispenser_i] = 0;
              //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
@@ -1618,11 +1673,17 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          DispenserPreSegmentControlId = 0xFF;
      }
 
+     IDS_Dispenser_Store_Data ();
+
      for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
          if (DispenserUsedInJob[Dispenser_i] == true)
          {
+#ifdef SPECIAL_DISPENSERS
+            IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+#else
             MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+#endif
             Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
             CurrentDispenserSpeed[Dispenser_i] = 0;