public void AnalyzeSignal_KnownSignal_ReturnsExpectedValues()
{
var audioStream = new MemoryStream();
var audioGenerator = new AudioGenerator(audioStream);
var fskAudioGenerator = new FskAudioGenerator(audioGenerator);
fskAudioGenerator.GenerateAudio(_binaryFskAnalyzerSettings.BaudRate,
_binaryFskAnalyzerSettings.SpaceFrequency, _binaryFskAnalyzerSettings.MarkFrequency,
_bitManipulator.StringToBits(Resources.LoremIpsumTestString));
var audioAnalyzer = new AudioAnalyzer(audioStream, audioGenerator);
var binaryFskAnalyzer = (IBinaryFskAnalyzer) new BinaryFskAnalyzer(audioAnalyzer, new ZeroCrossingsFrequencyDetector(), _binaryFskAnalyzerSettings);
var results = binaryFskAnalyzer.AnalyzeSignal();
var result = binaryFskAnalyzer.AnalyzeSignal();
var bits = new List <bool>();
foreach (var frame in result.AnalysisFrames)
{
if (frame.Bit.HasValue == true)
{
bits.Add(frame.Bit.Value);
}
}
var ascii = BitManipulator.BitsToString(bits);
Assert.AreEqual(Resources.LoremIpsumTestString, ascii);
}
public void When_inserting_number_in_host(
int host,
int insert,
int i,
int j,
int expectedAnswer)
{
var bitMan = new BitManipulator();
var result = bitMan.InsertBinaryNumber(host, insert, i, j);
Assert.Equal(expectedAnswer, result);
}
public void TestInitialize()
{
_audioAnalyzer = new Mock <IAudioAnalyzer>();
_frequencyDetector = new Mock <IFrequencyDetector>();
_bitManipulator = new BitManipulator();
_binaryFskAnalyzerSettings = new BinaryFskAnalyzerSettings
{
BaudRate = 300.0,
SpaceFrequency = 1000,
MarkFrequency = 1500
};
}
public TestRunner(BinaryFskAnalyzerSettings binaryFskAnalyzerSettings = null,
IFrequencyDetector frequencyDetector = null)
{
_audioStream = new MemoryStream();
_audioGenerator = new AudioGenerator(_audioStream);
_fskAudioGenerator = new FskAudioGenerator(_audioGenerator);
_binaryFskAnalyzerSettings = binaryFskAnalyzerSettings != null ? binaryFskAnalyzerSettings : new Bell103BinaryFskAnalyzerSettings();
var bitManipulator = new BitManipulator();
_fskAudioGenerator.GenerateAudio(_binaryFskAnalyzerSettings.BaudRate, _binaryFskAnalyzerSettings.SpaceFrequency,
_binaryFskAnalyzerSettings.MarkFrequency, bitManipulator.StringToBits("Test string"));
_audioAnalyzer = new AudioAnalyzer(_audioStream, _audioGenerator);
_frequencyDetector = frequencyDetector != null ? frequencyDetector : new ZeroCrossingsFrequencyDetector();
FskAnalyzer = new BinaryFskAnalyzer(_audioAnalyzer, _frequencyDetector, _binaryFskAnalyzerSettings);
}
public void Render(List <List <bool> > bytes)
{
foreach (var byteBlock in bytes)
{
if (byteBlock.Count < 8)
{
break;
}
// var bits = ChangeBit(byteBlock, 8, 0);
// bits.Reverse();
Console.Write(BitManipulator.ByteToChar(byteBlock));
}
Console.WriteLine();
}
public static void Main(string[] args)
{
var bitManipulator = new BitManipulator();
var myBits = bitManipulator.StringToBits(Resources.BigLebowskiQuote);
Console.WriteLine($"Length of string in bits: {myBits.Count}");
var audioStream = new MemoryStream();
var binaryFskAnalyzerSettings = new Bell103BinaryFskAnalyzerSettings();
var audioGenerator = new AudioGenerator(audioStream);
var fskAudioGenerator = new FskAudioGenerator(audioGenerator);
fskAudioGenerator.GenerateAudio(binaryFskAnalyzerSettings.BaudRate,
binaryFskAnalyzerSettings.SpaceFrequency, binaryFskAnalyzerSettings.MarkFrequency, myBits);
var audioLengthInMicroseconds = (int)(myBits.Count * Math.Pow(10, 6) / binaryFskAnalyzerSettings.BaudRate);
Console.WriteLine($"Length of audio in seconds: {audioLengthInMicroseconds / Math.Pow(10, 6):N1}");
Console.WriteLine();
Console.WriteLine(Resources.BigLebowskiQuote);
Console.WriteLine();
AudioAnalyzer.Play(audioStream, audioLengthInMicroseconds / 1000);
audioGenerator = new AudioGenerator(audioStream);
fskAudioGenerator = new FskAudioGenerator(audioGenerator);
fskAudioGenerator.GenerateAudio(binaryFskAnalyzerSettings.BaudRate,
binaryFskAnalyzerSettings.SpaceFrequency, binaryFskAnalyzerSettings.MarkFrequency, myBits);
var binaryFskAnalyzer = new BinaryFskAnalyzer(new AudioAnalyzer(audioStream, audioGenerator), new ZeroCrossingsFrequencyDetector(), binaryFskAnalyzerSettings);
Console.WriteLine($"Window position start {binaryFskAnalyzerSettings.WindowPositionStartMicroseconds:N3} us, window position end {binaryFskAnalyzerSettings.WindowPositionEndMicroseconds:N3} us, window position increment {binaryFskAnalyzerSettings.WindowPositionIncrementMicroseconds:N3} us");
Console.WriteLine($"Window length start {binaryFskAnalyzerSettings.WindowLengthStartMicroseconds:N3} us, window length end {binaryFskAnalyzerSettings.WindowLengthEndMicroseconds:N3} us, window length increment {binaryFskAnalyzerSettings.WindowLengthIncrementMicroseconds:N3} us");
Console.WriteLine();
var result = binaryFskAnalyzer.AnalyzeSignal();
var bits = new List <bool>();
foreach (var frame in result.AnalysisFrames)
{
if (frame.Bit.HasValue == true)
{
bits.Add(frame.Bit.Value);
}
}
Console.WriteLine("Rendering bytes");
Console.WriteLine();
var renderer = (IRenderer) new RowRenderer();
renderer.Render(BitManipulator.BitsToBytes(bits));
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Rendering ASCII");
Console.WriteLine();
renderer = new AsciiRenderer();
renderer.Render(BitManipulator.BitsToBytes(bits));
Console.WriteLine();
Console.WriteLine("Done");
Console.ReadLine();
}
private static void RandomExercises()
{
int[] numValues = { 8, 1, 2, 2, 3 };
ArrayExercises.SmallerNumbersThanCurrent(numValues);
int[] FirstDuplicate = { 2, 1, 3, 5, 3, 2 };
Console.WriteLine(string.Format("{0} is the first duplicate.", ArrayExercises.FindFirstDuplicate(FirstDuplicate)));
BinaryTree <int> MyTree = new BinaryTree <int>();
MyTree.Insert(6);
MyTree.Insert(7);
MyTree.Insert(8);
MyTree.Insert(2);
MyTree.Insert(7);
MyTree.Insert(1);
MyTree.Insert(3);
MyTree.Insert(9);
MyTree.Insert(1);
MyTree.Insert(4);
MyTree.Insert(5);
MyTree.SumEvenGrandparent(MyTree.Find(6));
long binary_val = 100100111000000;
BitManipulator x = new BitManipulator();
Console.WriteLine(x.GetDecimalValue(binary_val));
int[] luis = ManyExercises.BeautifulArray(4);
int[] arri = { 1, 1, 2, 3, 3, 4, 4, 8, 8 };
int UniqueVal = ManyExercises.SingleNonDuplicate(arri);
if (UniqueVal > -1)
{
Console.WriteLine(string.Format("Unique value is {0}.", UniqueVal));
}
else
{
Console.WriteLine("No unique value is found in given array.");
}
Console.WriteLine("\n");
string a = "kqep";
string b = "pekeq";
CustomSortString.SortString(a, b);
int[] Pancakes = { 3, 2, 4, 1 };
ArrayExercises.PancakeSort(Pancakes);
// [[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]]
int[][] matrix = new int[5][] { new int[] { 11, 25, 66, 1, 69, 7 }, new int[] { 23, 55, 17, 45, 15, 52 }, new int[] { 75, 31, 36, 44, 58, 8 }, new int[] { 22, 27, 33, 25, 68, 4 }, new int[] { 84, 28, 14, 11, 5, 50 } };
Console.WriteLine("Original Matrix:");
PrintMatrix(matrix);
JaggedArray.DiagonalSort(matrix);
Console.WriteLine("\nDiagonally Sorted Matrix:");
PrintMatrix(matrix);
Console.ReadLine();
int[] arr = { 8, 3, 2, 7, 9, 1, 4, 1 };
Console.WriteLine("\n");
Console.WriteLine("Before SelectionSort:");
foreach (int i in arr)
{
Console.Write(i + ",");
}
Console.ReadLine();
SelectionSortAlgorithm.SelectionSort(arr);
Console.WriteLine("\n");
Console.WriteLine("After SelectionSort:");
foreach (int i in arr)
{
Console.Write(i + ",");
}
Console.WriteLine("\n");
Console.ReadLine();
Console.Write("Binary Search. Enter number to search for: ");
int.TryParse(Console.ReadLine(), out int key);
BinarySearchAlgorithm.BinarySearch(arr, key);
arr = Sorting();
int[] G = { 1, 2, 3, 3, 4, 5 };
Console.WriteLine(OneDimensionalArray.FindDuplicate(G));
Console.ReadLine();
int[] arrX1 = { 3, 4, -7, 1, 3, 3, 1, -4 };
OneDimensionalArray.FindSubarrayForGivenSum(arrX1, 7);
var y1 = new int[] { 3, 1, 7, 5, 4, 9, 2 };
InsertionSortAlgorithm.InsertionSortBitWise(y1);
PrintResults(y1);
//ArrayExercises.StoreElementsInArray();
var x1 = new int[] { 1, 2, 3 };
var x2 = new int[] { 1, 2, 3 };
ArrayExercises.MergeToArraysSameSizeSorted(x1, x2);
LeetCode lc = new LeetCode();
var groupSizes = new int[] { 3, 3, 3, 3, 3, 1, 3 };
var List111 = OneDimensionalArray.GroupThePeople(groupSizes);
int[][] indices = new int[3][] { new int[] { 0, 0, 0 }, new int[] { 0, 0, 0 }, new int[] { 0, 0, 0 } };
lc.OddCells(2, 3, indices);
}
public AnalysisResult AnalyzeSignal(string testString = null)
{
var baudRateIncrementMicroseconds = 1.0 / _settings.BaudRate * Math.Pow(10, 6);
var windowPositionEndMicroseconds = _audioAnalyzer.FileLengthInMicroseconds;
var frequencyDifferences = new List <int>();
int numberOfZeroFrequencies = 0;
var analysisFrames = new List <AnalysisFrame>();
var i = 0;
for (var currentWindowPositionMicroseconds = 0.0; currentWindowPositionMicroseconds < windowPositionEndMicroseconds; currentWindowPositionMicroseconds += baudRateIncrementMicroseconds)
{
// Debug.WriteLine($"Current pos: {currentWindowPositionMicroseconds:N1}, increment: {baudRateIncrementMicroseconds:N1}, end: {windowPositionEndMicroseconds :N1}");
i++;
var samplingResult = _audioAnalyzer.GetSamples(currentWindowPositionMicroseconds, currentWindowPositionMicroseconds + baudRateIncrementMicroseconds);
// TODO: How to set this threshold?
var targetNumberOfSamples = _audioAnalyzer.SampleRate / Math.Pow(10, 6) * baudRateIncrementMicroseconds;
var sampleThreshold = 0.9;
if (samplingResult.Samples.Count() < (targetNumberOfSamples * sampleThreshold))
{
continue;
}
var frequency = _frequencyDetector.DetectFrequency(samplingResult.Samples);
var frequencyDifference = FrequencyDifference(frequency, _settings.SpaceFrequency, _settings.MarkFrequency);
var markOrSpace = MarkOrSpace(frequency, _settings.SpaceFrequency, _settings.MarkFrequency);
if (frequency <= 0)
{
numberOfZeroFrequencies++;
}
if (frequencyDifference > _settings.FrequencyDeviationTolerance)
{
Debug.WriteLine($"WARN: @ {currentWindowPositionMicroseconds / Math.Pow(10, 6):N3} seconds (Baud rate {_settings.BaudRate}) [{i}] outside of tolerance (frequency {frequency} Hz, difference {frequencyDifference} Hz, tolerance {_settings.FrequencyDeviationTolerance} Hz)");
frequencyDifferences.Add(frequencyDifference);
}
// Debug.WriteLine($"[{currentWindowStart:N3} us to {currentWindowStart + currentWindowLength:N3} us ({(currentWindowStart + currentWindowLength) - currentWindowStart:N3} us)] {frequency:N0} Hz average (+/- {frequencyDifference:N0} Hz) [Want {_settings.MarkFrequency:N0} Hz / {_settings.SpaceFrequency:N0} Hz] -> bit {bits.Count}: {markOrSpace}");
analysisFrames.Add(
new AnalysisFrame
{
Bit = (frequency > 0 && frequencyDifference <= _settings.FrequencyDeviationTolerance) ? (markOrSpace == 0 ? false : true) : (bool?)null,
Frequency = frequency,
DecodeFailure = frequency > _settings.FrequencyDeviationTolerance ? true : false,
DifferenceFromExpectedFrequencies = frequencyDifference,
TimeOffsetMicroseconds = currentWindowPositionMicroseconds
}
);
}
var analysisResult = new AnalysisResult
{
AnalysisFrames = analysisFrames,
NumberOfFrequencyDifferences = frequencyDifferences.Count(),
NumberOfZeroFrequencies = numberOfZeroFrequencies,
MinimumFrequencyDifference = frequencyDifferences.Count() > 0 ? frequencyDifferences.Min() : 0,
MaximumFrequencyDifference = frequencyDifferences.Count() > 0 ? frequencyDifferences.Max() : 0,
AverageFrequencyDifference = frequencyDifferences.Count() > 0 ? frequencyDifferences.Average() : 0
};
bool? match = null;
string resultingString = null;
if (testString != null)
{
var bits = new List <bool>();
analysisFrames.Where(x => x.Bit.HasValue == true).Select(x => x).ForEach(x => bits.Add(x.Bit.Value));
resultingString = BitManipulator.BitsToString(bits);
match = false;
if (resultingString == testString)
{
match = true;
}
}
// Debug.WriteLine($"Boost freq.: {_audioAnalyzer.BoostFrequencyAmount} Hz, avg. freq. diff.: {averageFrequencyDifference}, # missed freqs.: {missedFrequencies}");
AnalysisComplete((int)_settings.BaudRate, _audioAnalyzer.BoostFrequencyAmount, analysisResult, resultingString, match);
return(analysisResult);
}
public void Run(TestRunnerArguments arguments)
{
var fileTimestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var bitManipulator = new BitManipulator();
var bits = bitManipulator.StringToBits(arguments.TestString);
for (var baudRate = arguments.BaudStart; baudRate <= arguments.BaudEnd; baudRate += arguments.BaudIncrement)
{
for (var loopBoostFrequency = arguments.BoostStart; loopBoostFrequency <= arguments.BoostEnd;
loopBoostFrequency += arguments.BoostIncrement)
{
_binaryFskAnalyzerSettings = new Bell103BinaryFskAnalyzerSettings
{
SpaceFrequency = arguments.SpaceFrequency,
MarkFrequency = arguments.MarkFrequency,
BaudRate = baudRate,
FrequencyDeviationTolerance = arguments.Tolerance
};
_audioStream = new MemoryStream();
_audioGenerator = new AudioGenerator(_audioStream);
_fskAudioGenerator = new FskAudioGenerator(_audioGenerator);
_fskAudioGenerator.GenerateAudio(_binaryFskAnalyzerSettings.BaudRate,
_binaryFskAnalyzerSettings.SpaceFrequency, _binaryFskAnalyzerSettings.MarkFrequency, bits);
var audioLengthInMicroseconds = (int)(bits.Count * Math.Pow(10, 6) / _binaryFskAnalyzerSettings.BaudRate);
_audioStream = new MemoryStream();
_audioGenerator = new AudioGenerator(_audioStream);
_fskAudioGenerator = new FskAudioGenerator(_audioGenerator);
var samples = _fskAudioGenerator.GenerateAudio(_binaryFskAnalyzerSettings.BaudRate,
_binaryFskAnalyzerSettings.SpaceFrequency, _binaryFskAnalyzerSettings.MarkFrequency, bits);
SignalGenerationComplete(bits.Count, audioLengthInMicroseconds, samples, _audioAnalyzer.SampleRate);
if (arguments.WriteFaveFiles == true)
{
using (var file = File.Create($"{fileTimestamp}_{baudRate}_baud.wav"))
{
var previousPosition = _audioStream.Position;
_audioStream.Position = 0;
_audioStream.CopyTo(file);
_audioStream.Position = previousPosition;
}
}
_binaryFskAnalyzerSettings = new Bell103BinaryFskAnalyzerSettings
{
SpaceFrequency = (int)(arguments.SpaceFrequency + loopBoostFrequency),
MarkFrequency = (int)(arguments.MarkFrequency + loopBoostFrequency),
BaudRate = baudRate,
FrequencyDeviationTolerance = arguments.Tolerance
};
_audioAnalyzer = new AudioAnalyzer(_audioStream, _audioGenerator, (int)loopBoostFrequency);
FskAnalyzer.Initialize(_audioAnalyzer, new ZeroCrossingsFrequencyDetector(), _binaryFskAnalyzerSettings);
FskAnalyzer.AnalyzeSignal(arguments.TestString);
if (arguments.PlayAudio == true)
{
AudioAnalyzer.Play(_audioStream, (int)Math.Ceiling((audioLengthInMicroseconds / Math.Pow(10, 3))));
}
}
}
}
