public bool EnqueueModelUpdateCommands(List <long> measurementGids)
        {
            bool   success;
            ushort length = 6;

            Dictionary <long, AnalogModbusData>   analogData   = new Dictionary <long, AnalogModbusData>();
            Dictionary <long, DiscreteModbusData> discreteData = new Dictionary <long, DiscreteModbusData>();

            MeasurementsCache.Clear();

            try
            {
                Dictionary <long, ISCADAModelPointItem> currentScadaModel = SCADAModel.CurrentScadaModel;

                foreach (long measurementGID in measurementGids)
                {
                    ISCADAModelPointItem scadaPointItem = currentScadaModel[measurementGID];
                    IWriteModbusFunction modbusFunction;

                    if (scadaPointItem is IAnalogSCADAModelPointItem analogSCADAModelPointItem)
                    {
                        modbusFunction = FunctionFactory.CreateWriteModbusFunction(new ModbusWriteCommandParameters(length,
                                                                                                                    (byte)ModbusFunctionCode.WRITE_SINGLE_REGISTER,
                                                                                                                    analogSCADAModelPointItem.Address,
                                                                                                                    analogSCADAModelPointItem.CurrentRawValue),
                                                                                   CommandOriginType.MODEL_UPDATE_COMMAND);

                        AnalogModbusData analogModbusData = new AnalogModbusData(analogSCADAModelPointItem.CurrentEguValue,
                                                                                 analogSCADAModelPointItem.Alarm,
                                                                                 measurementGID,
                                                                                 CommandOriginType.MODEL_UPDATE_COMMAND);
                        analogData.Add(measurementGID, analogModbusData);
                    }
                    else if (scadaPointItem is IDiscreteSCADAModelPointItem discreteSCADAModelPointItem)
                    {
                        modbusFunction = FunctionFactory.CreateWriteModbusFunction(new ModbusWriteCommandParameters(length,
                                                                                                                    (byte)ModbusFunctionCode.WRITE_SINGLE_COIL,
                                                                                                                    discreteSCADAModelPointItem.Address,
                                                                                                                    discreteSCADAModelPointItem.CurrentValue),
                                                                                   CommandOriginType.MODEL_UPDATE_COMMAND);

                        DiscreteModbusData discreteModbusData = new DiscreteModbusData(discreteSCADAModelPointItem.CurrentValue,
                                                                                       discreteSCADAModelPointItem.Alarm,
                                                                                       measurementGID,
                                                                                       CommandOriginType.MODEL_UPDATE_COMMAND);
                        discreteData.Add(measurementGID, discreteModbusData);
                    }
                    else
                    {
                        Logger.LogWarn("Unknown type of ISCADAModelPointItem.");
                        continue;
                    }

                    this.modelUpdateQueue.Enqueue(modbusFunction);
                }

                MakeAnalogEntryToMeasurementCache(analogData, true);
                MakeDiscreteEntryToMeasurementCache(discreteData, false);

                success = true;
                this.writeCommandQueue = new ConcurrentQueue <IWriteModbusFunction>();
                this.readCommandQueue  = new ConcurrentQueue <IReadModbusFunction>();
                this.commandEvent.Set();
            }
            catch (Exception e)
            {
                success = false;
                string message = "Exception caught in EnqueueModelUpdateCommands() method.";
                Logger.LogError(message, e);
            }

            return(success);
        }