public void ConversionRoundTrip()
        {
            RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1);

            Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(revolutionpersecond.RevolutionsPerMinute).RevolutionsPerSecond, RevolutionsPerMinuteTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(revolutionpersecond.RevolutionsPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance);
        }
Ejemplo n.º 2
0
        public void ShouldGetTheRpm()
        {
            string          message      = "41 0C 55 54";
            RotationalSpeed expectedData = RotationalSpeed.FromRevolutionsPerMinute(5461);

            _response.Parse(message);
            Assert.AreEqual(expectedData, _response.Rpm);
        }
Ejemplo n.º 3
0
        public void ShouldCalculateTheRpmFromTheResponse()
        {
            string          data        = "5554";
            RotationalSpeed expectedRpm = RotationalSpeed.FromRevolutionsPerMinute(5461);
            RotationalSpeed actualRpm   = _response.CalculateRpm(data);

            Assert.AreEqual(expectedRpm, actualRpm);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Internal constructor from NMEA string
        /// </summary>
        public EngineRevolutions(TalkerId talkerId, IEnumerable <string> fields, DateTimeOffset time)
            : base(talkerId, Id, time)
        {
            IEnumerator <string> field = fields.GetEnumerator();

            string source   = ReadString(field);
            int?   engineNo = ReadInt(field);
            double?rpm      = ReadValue(field);
            double?pitch    = ReadValue(field);
            string status   = ReadString(field);

            if (source == "S")
            {
                RotationSource = RotationSource.Shaft;
            }
            else if (source == "E")
            {
                RotationSource = RotationSource.Engine;
            }
            else
            {
                RotationSource = RotationSource.Unknown;
            }

            if (engineNo.HasValue)
            {
                EngineNumber = engineNo.Value;
            }
            else
            {
                EngineNumber = 1;
            }

            if (rpm.HasValue)
            {
                RotationalSpeed = RotationalSpeed.FromRevolutionsPerMinute(rpm.Value);
            }
            else
            {
                RotationalSpeed = RotationalSpeed.Zero;
            }

            if (pitch.HasValue)
            {
                PropellerPitch = Ratio.FromPercent(pitch.Value);
            }

            if (rpm.HasValue && status == "A")
            {
                Valid = true;
            }
            else
            {
                Valid = false;
            }
        }
Ejemplo n.º 5
0
        public RotationalSpeed CalculateRpm(string data)
        {
            byte[] rpmBytes = StringToByteArray(data);
            if (rpmBytes != null)
            {
                double rpm = ((rpmBytes[0] * 256) + rpmBytes[1]) / 4f;
                return(RotationalSpeed.FromRevolutionsPerMinute(rpm));
            }

            throw new NullReferenceException("rpmBytes");
        }
        public void ConversionRoundTrip()
        {
            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);

            Assert.AreEqual(1, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond, RevolutionsPerMinuteTolerance);
            Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond, RevolutionsPerSecondTolerance);
        }
 /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(UnitsNet.QuantityValue)" />
 public static RotationalSpeed RevolutionsPerMinute <T>(this T value) =>
 RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
Ejemplo n.º 8
0
        static void Main(string[] args)
        {
            // nema17 - 24v datasheet
            var MOTOR_TYPE    = "nema17";
            var MOTOR_VOLTAGE = ElectricPotentialDc.FromVoltsDc(24);
            var SPEED_MAX     = RotationalSpeed.FromRevolutionsPerMinute(200);
            var TORQUE_MAX    = Torque.FromNewtonMeters(0.4);
            // problem data
            var MASS           = Mass.FromKilograms(2);
            var LEVER_ARM_LEN  = Length.FromCentimeters(1);
            var ROUND_CNT      = Angle.FromRevolutions(1d);
            var EXECUTION_TIME = Duration.FromSeconds(2);
            // config
            var TIME_STEP = Duration.FromMilliseconds(1);

            // speed required to achieve given ROUND_CNT in EXECUTION_TIME without cruise
            var minTargetSpeed = 2 * ROUND_CNT / EXECUTION_TIME;

            if (minTargetSpeed > SPEED_MAX)
            {
                System.Console.WriteLine($"W: given position {ROUND_CNT} round cannot established due to speed_max:{SPEED_MAX.RevolutionsPerSecond} rps vs actual required target speed:{minTargetSpeed.RevolutionsPerSecond} rps");
                return;
            }

            // s:target speed
            var s = minTargetSpeed;

            // d:duration
            var d = EXECUTION_TIME;

            var minHoldingTorque = Torque.FromKilogramForceCentimeters(MASS.Kilograms * LEVER_ARM_LEN.Centimeters);

            if (minHoldingTorque > TORQUE_MAX)
            {
                System.Console.WriteLine($"W: given mass {MASS} at lever arm distance {LEVER_ARM_LEN} generate {minHoldingTorque.KilogramForceCentimeters} kgfcm torque versus max {TORQUE_MAX.KilogramForceCentimeters} kgfcm");
                return;
            }

            var minDynAccel = RotationalAcceleration.FromRevolutionsPerSecondSquared(4 * s.RevolutionsPerSecond / d.Seconds);
            var I           = MassMomentOfInertia.FromKilogramSquareCentimeters(MASS.Kilograms * Pow(LEVER_ARM_LEN.Centimeters, 2));
            // torque            = inertia * angularaccel
            // F:[M*L*T-2]*r:[L] = I:[M*L2]*a:[T-2]
            // [M*L2*T-2]        = [M*L2*T-2]
            var minDynTorque = Torque.FromKilogramForceMeters(I.KilogramSquareMeters * minDynAccel.RadiansPerSecondSquared);

            if (minDynTorque > TORQUE_MAX)
            {
                System.Console.WriteLine($"W: accelerating given mass {MASS} at angaccel {minDynAccel} generates torque {minDynTorque.NewtonCentimeters} Ncm great than max {TORQUE_MAX.NewtonCentimeters} Ncm");
                return;
            }

            var srcPathfilename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "template.xlsx");
            var dstPathfilename = "output.xlsx";

            File.Copy(srcPathfilename, dstPathfilename, true);
            using (var wb = new ClosedXML.Excel.XLWorkbook(dstPathfilename))
            {
                var ws = wb.Worksheets.First();

                IXLCell cell = null;

                Action <int, int, object> setCell = (r, c, val) =>
                {
                    cell       = ws.Cell(r, c);
                    cell.Value = val;
                };

                Action <int, int, object> setCellBold = (r, c, val) =>
                {
                    cell       = ws.Cell(r, c);
                    cell.Value = val;
                    cell.Style.Font.SetBold();
                };

                var row       = 1;
                int col       = 1;
                var colTime   = col++;
                var colAccel  = col++;
                var colSpeed  = col++;
                var colPosRot = col++;

                setCellBold(row, colTime, "TIME (s)");
                setCellBold(row, colAccel, "ACCEL (rps2)");
                setCellBold(row, colSpeed, "SPEED (rps)");
                setCellBold(row, colPosRot, "POS (rot)");
                ++row;

                var t    = Duration.FromSeconds(0);
                var tMax = t + EXECUTION_TIME;

                var halfTMax = tMax / 2;

                ws.Cell("MotorType").Value                 = MOTOR_TYPE;
                ws.Cell("MotorSpeedMax").Value             = SPEED_MAX;
                ws.Cell("MotorTorqueMaxAtSpeedMax").Value  = TORQUE_MAX;
                ws.Cell("MotorVoltage").Value              = MOTOR_VOLTAGE;
                ws.Cell("ProblemDuration").Value           = EXECUTION_TIME;
                ws.Cell("ProblemLoadLeverArmLength").Value = LEVER_ARM_LEN;
                ws.Cell("ProblemLoadMass").Value           = MASS;
                ws.Cell("ProblemRevolutions").Value        = ROUND_CNT;
                ws.Cell("ResultingTorque").Value           = minDynTorque.ToUnit(TorqueUnit.NewtonMeter);
                ws.Cell("ResultingAccel").Value            = minDynAccel;
                ws.Cell("ResultingSpeedMax").Value         = minTargetSpeed.ToUnit(RotationalSpeedUnit.RevolutionPerMinute);

                var tEps = Duration.FromNanoseconds(1);
                while (t.LessThanOrEqualsTol(tEps, tMax))
                {
                    setCell(row, colTime, t.Seconds);

                    var accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(0);
                    var speed = RotationalSpeed.FromRevolutionsPerSecond(0);
                    var pos   = Angle.FromRevolutions(0);

                    if (t.LessThanOrEqualsTol(tEps, halfTMax))
                    {
                        accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(
                            2 * s.RevolutionsPerSecond / d.Seconds * (1 - Cos(4 * PI * t / d)));

                        speed = RotationalSpeed.FromRevolutionsPerSecond(
                            2 * s.RevolutionsPerSecond / d.Seconds * (t - d * Sin(4 * PI * t / d) / (4 * PI)).Seconds);

                        pos = s * d * (Cos(4 * PI * t / d) - 1) / (8 * Pow(PI, 2)) + (s * t) * (t / d);
                    }

                    if (t.GreatThanOrEqualsTol(tEps, halfTMax))
                    {
                        var th = t - d / 2;

                        accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(
                            2 * s.RevolutionsPerSecond / d.Seconds * (Cos(4 * PI * th / d) - 1));

                        speed = RotationalSpeed.FromRevolutionsPerSecond(
                            2 * s.RevolutionsPerSecond * Sin(4 * PI * th / d) / (4 * PI)
                            - (2 * s * th / d - s).RevolutionsPerSecond);

                        pos = s * d * (1 - Cos(4 * PI * th / d)) / (8 * Pow(PI, 2)) - (s * th) * (th / d) + s * th + s * d / 4;
                    }

                    setCell(row, colAccel, accel.RevolutionsPerSecondSquared);
                    setCell(row, colSpeed, speed.RevolutionsPerSecond);
                    setCell(row, colPosRot, pos.Revolutions);

                    ++row;
                    t += TIME_STEP;
                }

                wb.Save();
            }
        }
 public void NumberToRevolutionsPerMinuteTest() =>
 Assert.Equal(RotationalSpeed.FromRevolutionsPerMinute(2), 2.RevolutionsPerMinute());
Ejemplo n.º 10
0
 /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double?)"/>
 public static RotationalSpeed?RevolutionsPerMinute(this decimal?value) => RotationalSpeed.FromRevolutionsPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value));
Ejemplo n.º 11
0
 /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double?)"/>
 public static RotationalSpeed?RevolutionsPerMinute(this float?value) => RotationalSpeed.FromRevolutionsPerMinute(value);
Ejemplo n.º 12
0
 /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double)"/>
 public static RotationalSpeed RevolutionsPerMinute(this double value) => RotationalSpeed.FromRevolutionsPerMinute(value);
Ejemplo n.º 13
0
 public static RotationalSpeed?RevolutionsPerMinute <T>(this T?value) where T : struct => RotationalSpeed.FromRevolutionsPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value));