//--------------------------------------------------------------------------//
// Funcion: filtro //
// //
// Descripcion: Funcion que filtra la señal de entrada para darle forma. Va //
// haciendiendo la convolucion entre los símbolos muestreados //
// y los coeficientes del filtro pero también se le añade //
// retraso. Paraf filtrar la señal los valores tienen que ser //
// de tipo fract32 y es por eso por lo que se hace la //
// conversiónde float a fract32 y viceversa //
// //
// Parametros de entrada: Ninguno //
// //
// Parametros de salida: Ninguno //
// //
//--------------------------------------------------------------------------//
void filtro () {
for(indice_muestras=0 ; indice_muestras<NUM_SOBREMUESTREADOS ; indice_muestras++)
{
left_in_fr32_real[indice_muestras]=float_to_fr32(simbolo_muestreado_real[indice_muestras]/VALOR_MAX_CONSTELACION);
left_in_fr32_imag[indice_muestras]=float_to_fr32(simbolo_muestreado_imag[indice_muestras]/VALOR_MAX_CONSTELACION);
}
for (indice_retraso = 0; indice_retraso < COEFICIENTES_FILTRO; indice_retraso++) {
retraso[indice_retraso] = 0;
}
fir_init(state,filter_fr32,retraso,COEFICIENTES_FILTRO,0);
fir_fr32(left_in_fr32_real,left_out_fr32_real,NUM_FILTRADOS_1,&state);
for (indice_retraso = 0; indice_retraso < COEFICIENTES_FILTRO; indice_retraso++) {
retraso[indice_retraso] = 0;
}
fir_init(state,filter_fr32,retraso,COEFICIENTES_FILTRO,0);
fir_fr32(left_in_fr32_imag,left_out_fr32_imag,NUM_FILTRADOS_1,&state);
for(indice_muestrasFiltradas=0 ; indice_muestrasFiltradas<NUM_FILTRADOS_1 ; indice_muestrasFiltradas++) {
left_out_float_real[indice_muestrasFiltradas] = VALOR_MAX_CONSTELACION*fr32_to_float(left_out_fr32_real[indice_muestrasFiltradas]);
left_out_float_imag[indice_muestrasFiltradas] = VALOR_MAX_CONSTELACION*fr32_to_float(left_out_fr32_imag[indice_muestrasFiltradas]);
}
}
int main(){
float input_data;
int32 output_data;
//Configure hardware
codec_init();
fir_init(banda1,banda2,banda3,banda4,banda5);
while(1){
//Processing data
if(DSK6713_DIP_get(3)==0){
//Initialize processing
leds_output(LED_STATE_ACTIVE);
while(DSK6713_DIP_get(3)==0){
input_data = codec_read();
output_data = fir_filter(input_data);
codec_write(output_data);
}
}
//Waiting
else{
leds_output(LED_STATE_WATING);
}
}
}
void blue_signal_processor_init()
{
fir_init( &blue_signal_fir, blue_fir_coefs, blue_fir_buffer, sizeof(blue_fir_buffer) / sizeof(uint8_t) );
memset( buffer, 0, sizeof(buffer) );
head = 0;
sum = 0;
}
/**
* Allocate a new Audio resampler
*
* @param arp Pointer to allocated audio resampler
* @param sampc_max Maximum number of source samples when downsampling
* @param srate_in Sample rate for the input in [Hz]
* @param ch_in Number of channels for the input
* @param srate_out Sample rate for the output in [Hz]
* @param ch_out Number of channels for the output
*
* @return 0 for success, otherwise error code
*/
int auresamp_alloc(struct auresamp **arp, size_t sampc_max,
uint32_t srate_in, uint8_t ch_in,
uint32_t srate_out, uint8_t ch_out)
{
struct auresamp *ar;
int err = 0;
if (!arp || !sampc_max || !srate_in || !srate_out)
return EINVAL;
ar = mem_zalloc(sizeof(*ar), destructor);
if (!ar)
return ENOMEM;
ar->sampv = mem_zalloc(sampc_max * 2, NULL);
if (!ar->sampv) {
err = ENOMEM;
goto out;
}
ar->sampc = sampc_max;
ar->ratio = 1.0 * srate_out / srate_in;
ar->ch_in = ch_in;
ar->ch_out = ch_out;
fir_init(&ar->fir);
if (ch_in == 1 && ch_out == 1)
ar->resample = resample;
else if (ch_in == 1 && ch_out == 2)
ar->resample = resample_mono2stereo;
else if (ch_in == 2 && ch_out == 1)
ar->resample = resample_stereo2mono;
else if (ch_in == 2 && ch_out == 2)
ar->resample = resample_stereo;
else {
err = EINVAL;
goto out;
}
ar->coeffv = fir_lowpass;
ar->coeffn = (int)ARRAY_SIZE(fir_lowpass);
out:
if (err)
mem_deref(ar);
else
*arp = ar;
return err;
}
/*=========================================================================*/
void main_task(VP_INT exinf)
{
int i;
/* Initialize FIR Objects */
for( i=0;i<numof(fir);++i)
fir_init( &fir[i] );
/* Audio Driver start as interrupt interval is 8 blocks, 4 channels*/
KzAudioStart( audio_cb, 48000, 8, 4 );
/* main_task exit */
ext_tsk();
}
int main()
{
fir_filter_t fir;
uint32_t i;
generate_input_data();
fir_init( &fir, blue_fir, blue_fir_buffer, sizeof(blue_fir_buffer)/sizeof(int8_t));
for( i = 0; i < 1024; i++ )
{
int8_t sample = fir_push_sample( &fir, data[i] );
printf( "%d\r\n", sample );
}
return 0;
}
void main()
{
int i,
nsamples,
tapLength;
fir_state_fr16 s;
nsamples = BUFFER_SIZE;
tapLength = BASE_TAPLENGTH ;
fir_init(s, h, delay, tapLength);
my_fir(IN, MY_OUT, nsamples, &s);
_fir(IN, OUT, nsamples, &s);
for (i = 0; i < BUFFER_SIZE; i++) {
DIFF[i] = OUT[i] - MY_OUT[i];
}
}
int main(int argc, char *argv[])
{
int status = EXIT_FAILURE;
FILE *infile = NULL;
FILE *outfile = NULL;
int16_t *inbuf = NULL, *tempbuf = NULL;
struct complex_sample *outbuf = NULL;
struct fir_filter *filt = NULL;
static const unsigned int max_chunk_size = 1024 * 1024 * 1024;
unsigned int chunk_size = 4096;
size_t n_read, n_written;
bool done = false;
if (argc < 3 || argc > 4) {
fprintf(stderr,
"Filter sc16q11 samples from <infile> and write"
"them to <outfile>.\n\n");
fprintf(stderr,
"Usage: %s <infile> <outfile> [# chunk size(samples)]\n",
argv[0]);
return EXIT_FAILURE;
}
if (argc == 4) {
bool valid;
chunk_size = str2uint(argv[3], 1, max_chunk_size, &valid);
if (!valid) {
fprintf(stderr, "Invalid chunk size: %s samples\n", argv[3]);
return EXIT_FAILURE;
}
}
filt = fir_init(rx_ch_filter, rx_ch_filter_len);
if (!filt) {
fprintf(stderr, "Failed to allocate filter.\n");
return EXIT_FAILURE;
}
inbuf = calloc(2*sizeof(int16_t), chunk_size);
if (!inbuf) {
perror("calloc");
goto out;
}
tempbuf = calloc(2*sizeof(int16_t), chunk_size);
if (!tempbuf) {
perror("calloc");
goto out;
}
outbuf = calloc(sizeof(struct complex_sample), chunk_size);
if (!outbuf) {
perror("calloc");
goto out;
}
infile = fopen(argv[1], "rb");
if (!infile) {
perror("Failed to open input file");
goto out;
}
outfile = fopen(argv[2], "wb");
if (!outfile) {
perror("Failed to open output file");
goto out;
}
while (!done) {
n_read = fread(inbuf, 2*sizeof(int16_t), chunk_size, infile);
done = n_read != chunk_size;
fir_process(filt, inbuf, outbuf, n_read);
//convert
conv_struct_to_samples(outbuf, (unsigned int) n_read, tempbuf);
n_written = fwrite(tempbuf, 2*sizeof(int16_t), n_read, outfile);
if (n_written != n_read) {
fprintf(stderr, "Short write encountered. Exiting.\n");
status = -1;
goto out;
}
}
status = 0;
out:
if (infile) {
fclose(infile);
}
if (outfile) {
fclose(outfile);
}
free(tempbuf);
free(inbuf);
free(outbuf);
fir_deinit(filt);
return status;
}
