コード例 #1
0
            public void setFrequencyResponse(FrequencyResponse f)
            {
                if (f.magnitudes.Count != frequencyResponseMagnitudes)
                {
                    throw new Exception("Frequency response magnitudes not of correct length!");
                }

                if (f.phases.Count != frequencyResponsePhases)
                {
                    throw new Exception("Frequency response phases not of correct length!");
                }

                this.frequencyResponse.Add(f);
            }
コード例 #2
0
ファイル: Chart.cs プロジェクト: Kira-Kotova/Optimization
        private AbstractFunc GetFunc(FuncType type)
        {
            AbstractFunc func;

            switch (type)
            {
            case FuncType.FrequencyResponse:
                func = new FrequencyResponse(DataInfo);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(type));
            }
            return(func);
        }
コード例 #3
0
            void Download()
            {
                int size = Marshal.SizeOf(typeof(Map));

                byte[] romContents   = new byte[size];
                uint   maxReadLength = 11;

                for (uint byteOffset = 0; byteOffset < size;)
                {
                    uint   readLength = (uint)Math.Min(maxReadLength, size - byteOffset);
                    byte[] tmp;
                    hwInterface.GetControllerRegister(ScopeController.FLASH, byteOffset, readLength, out tmp);
                    Array.Copy(tmp, 0, romContents, byteOffset, readLength);
                    byteOffset += readLength;
                }
                Map m = BytesToMap(romContents);

                this.plugCount       = m.plugCount;
                this.AdcTimingValue  = m.adcTimingValue;
                this.gainCalibration = new List <GainCalibration>();
                int offset = 0;

                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double divider in SmartScope.validDividers)
                    {
                        foreach (double multiplier in SmartScope.validMultipliers)
                        {
                            GainCalibration c = new GainCalibration()
                            {
                                channel    = ch,
                                divider    = divider,
                                multiplier = multiplier
                            };
                            double[] coeff = new double[gainCalibrationCoefficients];

                            unsafe
                            {
                                for (int i = 0; i < coeff.Length; i++)
                                {
                                    coeff[i] = (double)m.gainCalibration[offset + i];
                                }
                            }
                            c.coefficients = coeff;
                            offset        += coeff.Length;

                            this.gainCalibration.Add(c);
                        }
                    }
                }
                computeDividersMultipliers();

                this.frequencyResponse = new List <FrequencyResponse>();
                int magnitudesOffset = 0;
                int phasesOffset     = 0;

                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double multiplier in SmartScope.validMultipliers)
                    {
                        try
                        {
                            FrequencyResponse f = new FrequencyResponse()
                            {
                                channel    = ch,
                                multiplier = multiplier,
                                phases     = new Dictionary <int, float>(),
                                magnitudes = new Dictionary <int, float>()
                            };
                            unsafe
                            {
                                for (int i = 0; i < frequencyResponsePhases; i++)
                                {
                                    f.phases.Add(m.phasesIndices[phasesOffset + i], m.phases[phasesOffset + i]);
                                }
                                phasesOffset += frequencyResponsePhases;
                                for (int i = 0; i < frequencyResponseMagnitudes; i++)
                                {
                                    f.magnitudes.Add(m.magnitudesIndices[magnitudesOffset + i], m.magnitudes[magnitudesOffset + i]);
                                }
                                magnitudesOffset += frequencyResponseMagnitudes;
                            }
                            this.frequencyResponse.Add(f);
                        }
                        catch (ArgumentException e)
                        {
                            Logger.Warn(String.Format("Failed to load frequency response from ROM for channel {0:G} and multiplier {1} [{2}]", ch, multiplier, e.Message));
                        }
                    }
                }
            }
コード例 #4
0
            void Upload()
            {
                //Fill ROM map structure
                Map m = new Map();

                m.plugCount      = plugCount;
                m.adcTimingValue = AdcTimingValue;
                int offset = 0;

                //FIXME: this code can be cleaner and shorter I suppose
                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double divider in SmartScope.validDividers)
                    {
                        foreach (double multiplier in SmartScope.validMultipliers)
                        {
                            double[] coeff = this.gainCalibration.Where(x => x.channel.Value == ch.Value && x.divider == divider && x.multiplier == multiplier).First().coefficients;
                            unsafe
                            {
                                for (int i = 0; i < coeff.Length; i++)
                                {
                                    m.gainCalibration[offset + i] = (float)coeff[i];
                                }
                            }
                            offset += coeff.Length;
                        }
                    }
                }

                int magnitudesOffset = 0;
                int phasesOffset     = 0;

                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double multiplier in SmartScope.validMultipliers)
                    {
                        try
                        {
                            FrequencyResponse f = this.frequencyResponse.Where(x => x.multiplier == multiplier && x.channel == ch).First();
                            unsafe
                            {
                                foreach (var kvp in f.magnitudes)
                                {
                                    m.magnitudesIndices[magnitudesOffset] = (ushort)kvp.Key;
                                    m.magnitudes[magnitudesOffset]        = kvp.Value;
                                    magnitudesOffset++;
                                }
                                foreach (var kvp in f.phases)
                                {
                                    m.phasesIndices[phasesOffset] = (ushort)kvp.Key;
                                    m.phases[phasesOffset]        = kvp.Value;
                                    phasesOffset++;
                                }
                            }
                        }
                        catch (InvalidOperationException)
                        {
                            Logger.Warn(String.Format("Failed to upload frequency response to ROM for channel {0:G} and multiplier {1}", ch, multiplier));
                            continue;
                        }
                    }
                }

                byte[] b = MapToBytes(m);

                uint writeOffset = (uint)Marshal.SizeOf(m.plugCount);

                while (writeOffset < b.Length)
                {
                    uint   writeLength = Math.Min(11, (uint)(b.Length - writeOffset));
                    byte[] tmp         = new byte[writeLength];
                    Array.Copy(b, writeOffset, tmp, 0, writeLength);
                    hwInterface.SetControllerRegister(ScopeController.FLASH, writeOffset, tmp);
                    writeOffset += writeLength;
                }
            }
コード例 #5
0
            public void setFrequencyResponse(FrequencyResponse f)
            {
                if (f.magnitudes.Count != frequencyResponseMagnitudes)
                    throw new Exception("Frequency response magnitudes not of correct length!");

                if (f.phases.Count != frequencyResponsePhases)
                    throw new Exception("Frequency response phases not of correct length!");

                this.frequencyResponse.Add(f);
            }
コード例 #6
0
            void Download()
            {
                int size = Marshal.SizeOf(typeof(Map));
                byte[] romContents = new byte[size];
                uint maxReadLength = 11;
                for (uint byteOffset = 0; byteOffset < size; )
                {
                    uint readLength = (uint)Math.Min(maxReadLength, size - byteOffset);
                    byte[] tmp;
                    hwInterface.GetControllerRegister(ScopeController.FLASH, byteOffset, readLength, out tmp);
                    Array.Copy(tmp, 0, romContents, byteOffset, readLength);
                    byteOffset += readLength;
                }
                Map m = BytesToMap(romContents);
                this.plugCount = m.plugCount;
                this.AdcTimingValue = m.adcTimingValue;
                this.gainCalibration = new List<GainCalibration>();
                int offset = 0;
                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double divider in SmartScope.validDividers)
                    {
                        foreach (double multiplier in SmartScope.validMultipliers)
                        {
                            GainCalibration c = new GainCalibration()
                            {
                                channel = ch,
                                divider = divider,
                                multiplier = multiplier
                            };
                            double[] coeff = new double[gainCalibrationCoefficients];

                            unsafe
                            {
                                for (int i = 0; i < coeff.Length; i++)
                                    coeff[i] = (double)m.gainCalibration[offset + i];
                            }
                            c.coefficients = coeff;
                            offset += coeff.Length;

                            this.gainCalibration.Add(c);
                        }
                    }
                }
                computeDividersMultipliers();

                this.frequencyResponse = new List<FrequencyResponse>();
                int magnitudesOffset = 0;
                int phasesOffset = 0;
                foreach (AnalogChannel ch in AnalogChannel.List)
                {
                    foreach (double multiplier in SmartScope.validMultipliers)
                    {
                        try
                        {
                            FrequencyResponse f = new FrequencyResponse()
                            {
                                channel = ch,
                                multiplier = multiplier,
                                phases = new Dictionary<int, float>(),
                                magnitudes = new Dictionary<int, float>()
                            };
                            unsafe
                            {
                                for (int i = 0; i < frequencyResponsePhases; i++)
                                    f.phases.Add(m.phasesIndices[phasesOffset + i], m.phases[phasesOffset + i]);
                                phasesOffset += frequencyResponsePhases;
                                for (int i = 0; i < frequencyResponseMagnitudes; i++)
                                    f.magnitudes.Add(m.magnitudesIndices[magnitudesOffset + i], m.magnitudes[magnitudesOffset + i]);
                                magnitudesOffset += frequencyResponseMagnitudes;
                            }
                            this.frequencyResponse.Add(f);
                        }
                        catch (ArgumentException e)
                        {
                            Logger.Warn(String.Format("Failed to load frequency response from ROM for channel {0:G} and multiplier {1} [{2}]", ch, multiplier, e.Message));
                        }
                    }
                }
            }