public void Reg0WriteTest()
        {
            RegisterData testData = new RegisterData
            {
                SlaveAddress      = 0xF, //15
                WriteRegisterData = new byte[1] {
                    8
                },
                ByteCount = 1
            };

            RFFECommand Reg0 = RFFECommand.Reg0Write;

            //Result should be 111100010001
            Reg0.CreateSourceData(testData, out uint[] sourceData, out int numByte);
            uint[] knownData = BitStringToArray("111100010001");

            CollectionAssert.AreEqual(sourceData, knownData, "Reg0Write data should match known data (medium data)");

            //Additional tests validate that the padding is correctly applied
            testData.SlaveAddress         = 0x1;
            testData.WriteRegisterData[0] = 0x1;
            Reg0.CreateSourceData(testData, out sourceData, out numByte);

            knownData = BitStringToArray("000100000010");
            CollectionAssert.AreEqual(sourceData, knownData, "Reg0Write data should match known data (min data)");

            testData.SlaveAddress         = 0xF;
            testData.WriteRegisterData[0] = 0x7F;
            Reg0.CreateSourceData(testData, out sourceData, out numByte);

            knownData = BitStringToArray("111111111111");
            CollectionAssert.AreEqual(sourceData, knownData, "Reg0Write data should match known data (max data)");
        }
Example #2
0
 static void CreateRFFEWaveforms(NIDigital niDigital, string pinName, RFFECommand rffeCommand)
 {
     //Create 1 bit sample width source and 8 bit sample width capture waveforms,
     //using appropriate name for the command.
     niDigital.SourceWaveforms.CreateSerial(pinName, rffeCommand.SourceName,
                                            SourceDataMapping.Broadcast, 1, BitOrder.MostSignificantBitFirst);
     niDigital.CaptureWaveforms.CreateSerial(pinName, rffeCommand.SourceName,
                                             8, BitOrder.MostSignificantBitFirst);
 }
Example #3
0
        public static ReadData BurstRFFE(NIDigital niDigital, RegisterData regData, string pinName,
                                         RFFECommand rffeCommand, TriggerConfiguration triggerConfig)
        {
            //Check data is valid
            rffeCommand.ValidateLogic(regData);

            //Create source and capture waveforms in driver
            CreateRFFEWaveforms(niDigital, pinName, rffeCommand);

            //Create dynamic source waveform data for selected command
            rffeCommand.CreateSourceData(regData, out uint[] sourceData, out int byteCount);
            niDigital.SourceWaveforms.WriteBroadcast(rffeCommand.SourceName, sourceData);

            //reg0 set based on amount of bytes used
            niDigital.PatternControl.WriteSequencerRegister("reg0", byteCount);

            //Burst pattern based on the input trigger settings
            Digital.InitiatePatternGeneration(niDigital, rffeCommand.SourceName, triggerConfig);

            //On read calls only, return capture data
            return(new ReadData());
        }