private void Process()
{
var wr = new StreamWriter("outputs.txt");
wr.Write(1);
wr.Write(";");
wr.Write(2);
wr.WriteLine(";");
wr.Close();
DesignContext.ExitProcess();
}
private float ReadNextValue(StreamReader sr)
{
string line;
float value;
do
{
line = sr.ReadLine();
if (line == null)
{
Log.WriteLine("End of Input Stream: Simulation Stops");
_tr_real.Close();
_tr_imag.Close();
data_fin.Next = true;
DesignContext.ExitProcess();
}
} while (!float.TryParse(line, out value));
return(value);
}
private async void Process()
{
float[,] sample = new float[16, 2];
uint index;
data_fin_out.Next = false;
do
{
data_req.Next = false;
data_ready.Next = false;
index = 0;
//Reading in the Samples
Log.WriteLine();
Log.WriteLine("Reading in the samples...");
while (index < 16)
{
data_req.Next = true;
do
{
await RisingEdge(CLK);
}while (!data_valid.Cur && !data_fin_in.Cur);
if (data_fin_in.Cur)
{
break;
}
sample[index, 0] = in_real.Cur;
sample[index, 1] = in_imag.Cur;
index++;
data_req.Next = false;
await RisingEdge(CLK);
}
if (index < 16)
{
break;
}
index = 0;
//////////////////////////////////////////////////////////////////////////
/// Computation - 1D Complex DFT In-Place DIF Computation Algorithm ////
//////////////////////////////////////////////////////////////////////////
//Size of FFT, N = 2**M
uint N, M, len;
float theta;
float[,] W = new float[7, 2];
float w_real, w_imag, w_rec_real, w_rec_imag, w_temp;
//Initialize
M = 4; N = 16;
len = N / 2;
theta = (float)(8.0 * Math.Atan(1.0) / N);
Log.WriteLine();
Log.WriteLine("Computing...");
//Calculate the W-values recursively
w_real = (float)Math.Cos(theta);
w_imag = (float)-Math.Sin(theta);
w_rec_real = 1;
w_rec_imag = 0;
index = 0;
while (index < len - 1)
{
w_temp = w_rec_real * w_real - w_rec_imag * w_imag;
w_rec_imag = w_rec_real * w_imag + w_rec_imag * w_real;
w_rec_real = w_temp;
W[index, 0] = w_rec_real;
W[index, 1] = w_rec_imag;
index++;
}
float tmp_real, tmp_imag, tmp_real2, tmp_imag2;
uint stage, i, j, index2, windex, incr;
//Begin Computation
stage = 0;
len = N;
incr = 1;
while (stage < M)
{
len = len / 2;
//First Iteration : With No Multiplies
i = 0;
while (i < N)
{
index = i; index2 = index + len;
tmp_real = sample[index, 0] + sample[index2, 0];
tmp_imag = sample[index, 1] + sample[index2, 1];
sample[index2, 0] = sample[index, 0] - sample[index2, 0];
sample[index2, 1] = sample[index, 1] - sample[index2, 1];
sample[index, 0] = tmp_real;
sample[index, 1] = tmp_imag;
i = i + 2 * len;
}
//Remaining Iterations: Use Stored W
j = 1; windex = incr - 1;
while (j < len) // This loop executes N/2 times at first stage, .. once at last stage.
{
i = j;
while (i < N)
{
index = i;
index2 = index + len;
tmp_real = sample[index, 0] + sample[index2, 0];
tmp_imag = sample[index, 1] + sample[index2, 1];
tmp_real2 = sample[index, 0] - sample[index2, 0];
tmp_imag2 = sample[index, 1] - sample[index2, 1];
sample[index2, 0] = tmp_real2 * W[windex, 0] - tmp_imag2 * W[windex, 1];
sample[index2, 1] = tmp_real2 * W[windex, 1] + tmp_imag2 * W[windex, 0];
sample[index, 0] = tmp_real;
sample[index, 1] = tmp_imag;
i = i + 2 * len;
}
windex = windex + incr;
j++;
}
stage++;
incr = 2 * incr;
}
//////////////////////////////////////////////////////////////////////////
//Writing out the normalized transform values in bit reversed order
Unsigned bits_i, bits_index;
bits_index = Unsigned.FromULong(0, 4);
bits_i = Unsigned.FromULong(0, 4);
i = 0;
Log.WriteLine("Writing the transform values...");
while (i < 16)
{
bits_i = Unsigned.FromULong(i, 4);
bits_index[3] = bits_i[0];
bits_index[2] = bits_i[1];
bits_index[1] = bits_i[2];
bits_index[0] = bits_i[3];
index = (uint)bits_index;
out_real.Next = sample[index, 0];
out_imag.Next = sample[index, 1];
data_ready.Next = true;
do
{
await RisingEdge(CLK);
}while (!data_ack.Cur);
data_ready.Next = false;
i++;
await RisingEdge(CLK);
}
index = 0;
Log.WriteLine("Done...");
} while (!data_fin_in.Cur);
data_fin_out.Next = true;
DesignContext.ExitProcess();
}
