I thought for a minute you may have been stating there was a licensing issue or something, please pardon my confusion....
Now, if you want to make a reasonable offer, it is all yours.
...
' create an N-point DFT X(k) from x(n). Returns magnitude spectrum
Sub DFT(sn() As Integer, retSk() As Long, N As Long)
Dim e() As Complex ' complex exponentials
Dim Sk As Complex ' our temporary complex DFT
Dim two_pi_on_N As Single
two_pi_on_N = 2.0*(ATan(1)*4)/N ' calculate 2pi/N
Dim i As Long, j As Long, k As Long
' do some precalculations of complex exponential term
ReDim e(0 To N - 1)
For i = 0 To N - 1 ' where i = (kn % N) in the DFT formula
e(i).re = Cos(-i * two_pi_on_N)
e(i).im = Sin(-i * two_pi_on_N)
Next i
For k = 0 To N - 1
Sk.re = 0
Sk.im = 0
For n = 0 To N - 1 ' calculate the complex DFT
Sk.re = Sk.re + sn(n) * e((k*n) % N).re
Sk.im = Sk.im + sn(n) * e((k*n) % N).im
Next n
' convert To magnitude, and store in user's buffer
retSk(i) = Sqrt(Sk.re*Sk.re + Sk.im*Sk.im)
Next k
End Sub/* create an N-point DFT X(k) from x(n). Returns magnitude spectrum */
void DFT(short sn[], int retSk[], int N)
{
complex e[N]; /* complex exponentials */
complex Sk; /* our temporary complex DFT */
float two_pi_on_N = 2.0*(atan(1)*4)/N; /* calculate 2pi/N */
int i, j, k;
/* do some precalculations of complex exponential term */
for(i = 0; i < N; i++) /* where i = (kn % N) in the DFT formula */
{
e[i].re = cos(-i * two_pi_on_N);
e[i].im = sin(-i * two_pi_on_N);
}
for(k = 0; k < N; k++)
{
Sk.re = 0;
Sk.im = 0;
for(n = 0; n < N; n++) /* calculate the complex DFT */
{
Sk.re += sn[n] * e[(k*n) % N].re;
Sk.im += sn[n] * e[(k*n) % N].im;
}
/* convert to magnitude, and store in user's buffer */
retSk[i] = sqrt(Sk.re*Sk.re + Sk.im*Sk.im);
}
}
.
typedef struct V_data { // ISR used, mainly for non-atomic mod problems
volatile uint32_t buttonint_count, timerint_count, eeprom_count, highint_count, lowint_count, c1_int, c2_int, hunt_count;
volatile uint32_t pwm4int_count, worker_count, b0, b1, b2, b3, display_count, lcdhits, lcdhits_18tcy, adc_count;
volatile uint32_t clock20, commint_count, status_count, c1rx_int;
volatile uint8_t blink, buzzertime, voice1time, voice2time, qei_counts;
} V_data;
struct V_data V;
#define LEDS LATC
void blink_led(uint8_t led, uint8_t start) // blink and store status of 4 leds
{
if (led > 3) return;
if (start) {
V.blink |= ((LEDS >> led)&0b00000001) << (led + 4); // read the state of the LED on the LATCH and store it on [4..7] of blink
V.blink |= 0b00000001 << led; // set the blink bit for the LED
} else {
V.blink &= ~(0b00000001 << led); // reset the blink bit for the LED
LEDS &= ~(0b00000001 << led); // reset the LEDS bit for the LED
LEDS |= (((V.blink >> (led + 4))&0b00000001) << led); // set the LEDS bit
}
}C/C++/C#/Matlab - they're much the same to me, though C is the least productive, and C# the most. C#, to me, has the most advanced environment to work in out of those mentioned. Matlab is great for uni for any problem that can be vectorised, but is horribly slow for code utilising nested loops; that's when embedding C++ libraries is handy, though I'd prefer they just improved Matlab to be able to handle such cases.
