public static string GetPumpStatusEnumText(PumpStatusEnum pumpStatusEnum)
 {
     try
     {
         return(Enum.GetName(typeof(PumpStatusEnum), (int)pumpStatusEnum));
         //switch (pumpStatusEnum)
         //{
         //    case PumpStatusEnum.Idle: return "Idle";
         //    case PumpStatusEnum.Reserved: return "Reserved";
         //    case PumpStatusEnum.Authorized: return "Authorized";
         //    case PumpStatusEnum.NozzlePickUp: return "NozzlePickUp";
         //    case PumpStatusEnum.StartedDispend: return "StartedDispend";
         //    case PumpStatusEnum.Dispensing: return "Dispensing";
         //    case PumpStatusEnum.DispenseCompleted: return "DispenseCompleted";
         //    case PumpStatusEnum.Finalized: return "Finalized";
         //    case PumpStatusEnum.NoRespond: return "NoRespond";
         //    case PumpStatusEnum.NoAuthorise: return "NoAuthorise";
         //    case PumpStatusEnum.PumpBlocked: return "PumpBlocked";
         //    case PumpStatusEnum.Disabled: return "Disabled";
         //    default: return $"[{pumpStatusEnum.ToString()}|{(int)pumpStatusEnum}]";
         //}
     }
     catch {
         //    Console.WriteLine("The 4th value of the Styles Enum is {0}", Enum.GetName(typeof(Styles), 3));
         //string res = Enum.GetName(typeof(PumpStatusEnum), (int)pumpStatusEnum);
         return($"[{(int)pumpStatusEnum}]");
         //return $"[{pumpStatusEnum.ToString()}|{(int)pumpStatusEnum}]";
     }
 }
        public static string GetPumpStatusEnum(PumpStatusEnum pumpStatusEnum)
        {
            switch (pumpStatusEnum)
            {
            case PumpStatusEnum.Idle: return("02");

            case PumpStatusEnum.Reserved: return("0#");

            case PumpStatusEnum.Authorized: return("0:");

            case PumpStatusEnum.NozzlePickUp: return("0;");

            case PumpStatusEnum.StartedDispend: return("0;");

            case PumpStatusEnum.Dispensing: return("0?");

            case PumpStatusEnum.DispenseCompleted: return("12");

            case PumpStatusEnum.Finalized: return("42");

            case PumpStatusEnum.NoRespond: return("00");

            case PumpStatusEnum.NoAuthorise: return("03");

            case PumpStatusEnum.PumpBlocked: return("82");

            case PumpStatusEnum.Disabled: return("7F");

            default: return($"[{pumpStatusEnum.ToString()}|{(int)pumpStatusEnum}]");
            }
        }
Esempio n. 3
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="pse"></param>
 /// <returns></returns>
 private PumpStatus IsPumpRun(PumpStatusEnum pse)
 {
     if (pse == PumpStatusEnum.Run)
     {
         return(PumpStatus.Run);
     }
     else if (pse == PumpStatusEnum.Stop)
     {
         return(PumpStatus.Stop);
     }
     throw new ArgumentException(pse.ToString());
 }
Esempio n. 4
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="value"></param>
 /// <returns></returns>
 static public PumpStatus Find(PumpStatusEnum value)
 {
     if (value == PumpStatusEnum.Run)
     {
         return(Run);
     }
     else if (value == PumpStatusEnum.Stop)
     {
         return(Stop);
     }
     else
     {
         throw new ArgumentException(value.ToString());
     }
 }
 /// <summary>
 /// Set story line parameter
 /// </summary>
 /// <param name="name">Description of story line, what happens here</param>
 /// <param name="pumpstatus">Curent Pump Status</param>
 /// <param name="nexttick">How long until next tick, (0=no step)</param>
 /// <param name="nextstatus">This will be next step Status of pump</param>
 /// <param name="nextStoryLine">This is number of next story line</param>
 /// <param name="statusTimeOut">Automatic Timeout of status (0=no auto)</param>
 /// <param name="canChangeStatus">Story line allows pump to change status</param>
 /// <param name="canResetPump">Story line allows Pump to Reset</param>
 public PumpStory(
     string name,
     PumpStatusEnum pumpstatus,
     int nexttick,
     PumpStatusEnum nextstatus,
     int nextStoryLine,
     long statusTimeOut,
     bool canChangeStatus,
     bool canResetPump
     )
 {
     pumpStoryName     = name; Name = name;
     Status            = pumpstatus;
     nextTick          = nexttick;
     NextStatus        = nextstatus;
     PumpStatusTimeOut = statusTimeOut;
     CanChangeStatus   = canChangeStatus;
     CanResetPump      = canResetPump;
     NextStoryLine     = nextStoryLine;
 }
 /// <summary>
 /// Set story line parameter
 /// </summary>
 /// <param name="name">Description of story line, what happens here</param>
 /// <param name="pumpstatus">Curent Pump Status</param>
 /// <param name="nexttick">How long until next tick, (0=no step)</param>
 /// <param name="nextstatus">This will be next step Status of pump</param>
 /// <param name="nextStoryLine">This is number of next story line</param>
 /// <param name="statusTimeOut">Automatic Timeout of status (0=no auto)</param>
 /// <param name="canChangeStatus">Story line allows pump to change status</param>
 /// <param name="canResetPump">Story line allows Pump to Reset</param>
 /// <param name="pctOfLimit">Story line Set Pct Of Limit to return as Amount</param>
 /// <param name="ppu">Story line Set Price Per Unit</param>
 public PumpStory(
     string name,
     PumpStatusEnum pumpstatus,
     int nexttick,
     PumpStatusEnum nextstatus,
     int nextStoryLine,
     long statusTimeOut,
     bool canChangeStatus,
     bool canResetPump,
     double pctOfLimit,
     double ppu
     )
 {
     pumpStoryName     = name; Name = name;
     Status            = pumpstatus;
     nextTick          = nexttick;
     NextStatus        = nextstatus;
     PumpStatusTimeOut = statusTimeOut;
     CanChangeStatus   = canChangeStatus;
     CanResetPump      = canResetPump;
     NextStoryLine     = nextStoryLine;
     PctOfLimit        = pctOfLimit;
     Ppu = ppu;
 }
 /// <summary>
 /// Set story line parameter
 /// </summary>
 /// <param name="name">Description of story line, what happens here</param>
 /// <param name="pumpstatus">Curent Pump Status</param>
 /// <param name="nexttick">How long until next tick, (0=no step)</param>
 /// <param name="nextstatus">This will be next step Status of pump</param>
 /// <param name="nextStoryLine">This is number of next story line</param>
 /// <param name="statusTimeOut">Automatic Timeout of status (0=no auto)</param>
 /// <param name="canChangeStatus">Story line allows pump to change status</param>
 /// <param name="canResetPump">Story line allows Pump to Reset</param>
 /// <param name="volume">Story line Set Volume</param>
 /// <param name="amount">Story line Set Amount</param>
 public PumpStory(
     string name,
     PumpStatusEnum pumpstatus,
     int nexttick,
     PumpStatusEnum nextstatus,
     int nextStoryLine,
     long statusTimeOut,
     bool canChangeStatus,
     bool canResetPump,
     decimal volume,
     decimal amount
     )
 {
     pumpStoryName     = name; Name = name;
     Status            = pumpstatus;
     nextTick          = nexttick;
     NextStatus        = nextstatus;
     PumpStatusTimeOut = statusTimeOut;
     CanChangeStatus   = canChangeStatus;
     CanResetPump      = canResetPump;
     NextStoryLine     = nextStoryLine;
     Volume            = volume;
     Amount            = amount;
 }
Esempio n. 8
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="value"></param>
 private PumpStatus(PumpStatusEnum value, string text)
 {
     this.PumpStatusEnum = value;
     this.Text           = text;
 }
Esempio n. 9
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="pse"></param>
 /// <returns></returns>
 private PumpStatus IsPumpRun(PumpStatusEnum pse)
 {
     if (pse == PumpStatusEnum.Run)
     {
         return PumpStatus.Run;
     }
     else if (pse == PumpStatusEnum.Stop)
     {
         return PumpStatus.Stop;
     }
     throw new ArgumentException(pse.ToString());
 }
Esempio n. 10
0
        /// <summary>
        /// Making story lines move to next step in scripted story
        /// </summary>
        /// <param name="pumpNo">Pump Number / Pump Story</param>
        public void NextStepHistory(int pumpNo)
        {
            if (Pumps.ContainsKey(pumpNo))
            {
                Pump           pump      = Pumps[pumpNo];
                PumpStatusEnum OrgStatus = pump.PumpStatus;
                if (Story.stationStories.ContainsKey(pumpNo))
                {
                    pumpStories = Story.stationStories[pumpNo];
                    PumpStory pumpStory = pumpStories[Story.stationStoriesLine[pumpNo]];

                    DateTime tick              = pump.PumpTime;
                    int      nextTick          = pumpStory.NextTick;
                    long     pumpStatusTimeOut = pumpStory.PumpStatusTimeOut;

                    // If NextTick is gt 0 then the story line will automatic do next step in the story linie
                    // And move on the story for next event to happen.
                    if (nextTick > 0)
                    {
                        if (DateTime.Compare(DateTime.Now, tick.AddSeconds(nextTick)) > 0)
                        {
                            Story.stationStoriesLine[pumpNo] = pumpStory.NextStoryLine;
                            string storytext = pumpStory.Name;
                            if (pumpStory.NextStatus.Equals(PumpStatusEnum.NozzlePickUp) || pumpStory.NextStatus.Equals(PumpStatusEnum.DispenseCompleted))
                            {
                                if (!pumpStory.Amount.Equals(0))
                                {
                                    pump.Amount = pumpStory.Amount; storytext += $"|Amount:{pump.Amount}";
                                }
                                if (!pumpStory.Volume.Equals(0))
                                {
                                    pump.Volume = pumpStory.Volume; storytext += $"|Volume:{pump.Volume}";
                                }

                                if (!pumpStory.PctOfLimit.Equals(0))
                                {
                                    pump.Amount = pump.Limit * ((decimal)pumpStory.PctOfLimit / 100M); storytext += $"|Amount:{pump.Amount}";
                                }
                                if (!pumpStory.Ppu.Equals(0))
                                {
                                    pump.Volume = pump.Amount / (decimal)pumpStory.Ppu; storytext += $"|Volume:{pump.Volume}";
                                }

                                decimal vol = pump.Volume; vol = vol.Equals(0) ? 1 : vol;
                                log.Debug(LogHelp.LogText(
                                              $"Pump #{pumpNo:00}: " +
                                              $"Status #{Enum.GetName(typeof(PumpStatusEnum), (int)pump.PumpStatus)}: " +
                                              $"Hose: {pump.Hose:0} " +
                                              $"Flag: {pump.Flag:0} " +
                                              $"Amount: {pump.Amount:N2}RM " +
                                              $"Volume: {pump.Volume:N3} " +
                                              $"Price pr unit: {(pump.Amount / (vol)):N3}RM " +
                                              $"Limit: {pump.Limit:N3}L"
                                              )
                                          );
                            }

                            pump.PumpStatus = pumpStory.NextStatus;
                            if (Pumps.ContainsKey(pumpNo))
                            {
                                Pumps.Remove(pumpNo);
                            }
                            Pumps.Add(pumpNo, pump);
                            log.Info(LogHelp.LogText($"Pump #{pumpNo:00}: " +
                                                     $"{Enum.GetName(typeof(PumpStatusEnum), (int)OrgStatus)} " +
                                                     $" =) " +
                                                     $"{Enum.GetName(typeof(PumpStatusEnum), (int)pumpStory.NextStatus)} " /*+*/
                                                                                                                           //$"\"{storytext}\""
                                                     )
                                     );
                        }
                    }

                    // If pumpStatusTimeOut is gt 0 then the Storyline will TimeOut, when the time become more
                    // than the timout value and reset the pump / story line to Zero / eg first step in story
                    if (nextTick.Equals(0) && !pumpStatusTimeOut.Equals(0))
                    {
                        if (DateTime.Compare(DateTime.Now, tick.AddSeconds(pumpStatusTimeOut)) > 0)
                        {
                            Story.stationStoriesLine[pumpNo] = 1;
                            pump.ResetPump();
                            pump.PumpStatus = PumpStatusEnum.Idle;

                            if (Pumps.ContainsKey(pumpNo))
                            {
                                Pumps.Remove(pumpNo);
                            }
                            Pumps.Add(pumpNo, pump);
                            log.Info(LogHelp.LogText($"Pump #{pumpNo:00}: " +
                                                     $"{Enum.GetName(typeof(PumpStatusEnum), (int)OrgStatus)} " +
                                                     $" =) " +
                                                     $"{Enum.GetName(typeof(PumpStatusEnum), (int)pumpStory.NextStatus)} " /*+*/
                                                                                                                           //$"\"{pumpStory.Name}\""
                                                     )
                                     );
                        }
                    }
                }
            }
        }
Esempio n. 11
0
        public void SetStatus(int pumpNo, PumpStatusEnum Status)
        {
            if (Pumps.ContainsKey(pumpNo))
            {
                Pump           pump      = Pumps[pumpNo];
                PumpStatusEnum OrgStatus = pump.PumpStatus;
                string         old       = Enum.GetName(typeof(PumpStatusEnum), (int)OrgStatus);
                string         ny        = Enum.GetName(typeof(PumpStatusEnum), (int)Status);

                // Pump #1: Idle => Reserved"
                if (Story.stationStories.ContainsKey(pumpNo))
                {
                    pumpStories = Story.stationStories[pumpNo];
                    PumpStory pumpStory = pumpStories[Story.stationStoriesLine[pumpNo]];

                    if (Status.Equals(PumpStatusEnum.Idle) && pumpStory.CanResetPump)
                    {
                        pump.ResetPump();
                        Story.stationStoriesLine[pumpNo] = 1;
                    }

                    if (Status.Equals(pumpStory.NextStatus))
                    {
                        pump.PumpStatus = Status;
                        Story.stationStoriesLine[pumpNo] = pumpStory.NextStoryLine;
                    }
                    if (Pumps.ContainsKey(pumpNo))
                    {
                        Pumps.Remove(pumpNo);
                    }
                    Pumps.Add(pumpNo, pump);

                    string storyText = "";
                    switch (pump.PumpStatus)
                    {
                    case PumpStatusEnum.Authorized:
                        if (OrgStatus.Equals(PumpStatusEnum.Reserved))
                        {
                            storyText = $"| ({pump.Volume:N3}L or {pump.Limit:N2}RM)";
                        }
                        break;

                    case PumpStatusEnum.Idle:
                        if (OrgStatus.Equals(PumpStatusEnum.DispenseCompleted))
                        {
                            storyText = $"| ({pump.Volume:N3}L or {pump.Amount:N2}RM)";
                        }
                        break;

                    default:
                        break;
                    }

                    old = Enum.GetName(typeof(PumpStatusEnum), (int)OrgStatus);
                    ny  = Enum.GetName(typeof(PumpStatusEnum), (int)Status);
                    log.Info(LogHelp.LogText($"Pump #{pumpNo:00}: {old} =) {ny} {storyText}"));
                }
                else
                {
                    pump.PumpStatus = Status;
                    if (Pumps.ContainsKey(pumpNo))
                    {
                        Pumps.Remove(pumpNo);
                    }
                    Pumps.Add(pumpNo, pump);

                    old = Enum.GetName(typeof(PumpStatusEnum), (int)OrgStatus);
                    ny  = Enum.GetName(typeof(PumpStatusEnum), (int)Status);
                    log.Warn(LogHelp.LogText($"Pump #{pumpNo:00}: No Pump Storie: {old} =) {ny}"));
                }
            }
            else
            {
                log.Error(LogHelp.LogText($"Pump #{pumpNo:00}: Does not exist"));
            }
        }
 public PumpStoryStatus(PumpStatusEnum StoryStatus)
 {
 }