Contents

1 Introducci’on

• Todos los medios de transmisi’on aten’uan las señales que transportan. Esta atenuaci’on produce un decremento en la energ’ia que transporta la señal y por tanto, cuanto m’as alejados est’an el emisor y el receptor, menor ser’a dicha energ’ia.
• La cantidad de energ’ia que se pierde durante la transmisi’on depende del tipo de medio¹ y de la frecuencia de la señal. Generalmente, las señales de mayor frecuencia se aten’uan m’as que las señales de menor frecuencia [1]. Por este motivo, por ejemplo, cuando nos acercamos a un lugar donde hay un concierto de m’usica escuchamos primero los sonidos de m’as baja frecuencia (el bombo de la bater’ia) y posteriormente el resto de instrumentos.
• En esta pr’actica vamos a estudiar c’omo afecta la atenuaci’on de las altas frecuencias de una señal digital a la forma de la misma.

2 Planteamiento de la pr’actica

• Vamos a usar una computadora digital para simular la transmisi’on de una señal a trav’es de un medio de transmisi’on que aten’ua las altas frecuencias.
• Como estamos interesados en la transmisi’on de señales con contenido digital, vamos a transmitir una señal muy sencilla que, con un voltaje de -1 Voltios codifique un 0 y con 1 Voltios, un 1.

3 Tratamiento digital de señales

• Es imposible tratar num’ericamente una señal (digital o no) en una computadora digital, si ’esta no ha sido previamente digitalizada.
• Por el razonamiento anterior, es imposible generar una señal mediante un sistema digital que no est’e discretizada en el tiempo.
• Como consecuencia, puede afirmarse que, todas las señales generadas en las computadoras digitales son señales digitalizadas.

4 La digizalizaci’on de señales

• Digitalizar una señal implica discretizarla en el tiempo y en amplitud.
• Como las computadoras digitales trabajan en precisi’on finita, todas las señales generadas en una computadora pueden discretizarse en amplitud sin p’erdida de informaci’on.
• El ancho de banda que ocupa una señal dititalizada viene determinado por el teorema del muestreo uniforme que indica, en funci’on del ancho de banda que ocupa una señal, cu’antas muestras son necesarias para representarla sin p’erdida de informaci’on.

5 El teorema del muestreo uniforme

• El teorema del muestreo uniforme afirma que si una señal est’a limitada en banda, esta puede ser discretizada en el tiempo, sin p’erdida de informaci’on.² Sea w_m la m’axima componente de frecuencia de la señal, medida en Hercios. Entonces deberemos tomar

  (1)

  muestras por segundo para que no exista p’erdida de informaci’on.

6 El n’umero de muestras y la precisi’on de la simulaci’on

• Como el objetivo de esta pr’actica es representar c’omo afecta la limitaci’on del ancho de banda a la forma de onda de una señal digital, y ’esto se hace mediante una simulaci’on digital, el n’umero de muestras que tomemos de la señal a transmitir va a afectar a la calidad de la representaci’on. A m’as muestras, mejores representaciones.
• El n’umero de muestras, en total, usadas para pintar las gr’afica es configurable aunque por requerimientos de la simulaci’on deber’a ser siempre una potencia de dos.

7 El “digitalizador”

• El programa http://www.ace.ual.es/\~vruiz/redes/practicas/sampler.c:
   
  /* 
   * sampler.c -- Muestrea una seal digital. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/practicas/sampler.c 
   * 
   * Compilar escribiendo: 
   * gcc sampler.c -o sampler spin.o 
   * 
   * gse. 2007 
   */ 
   
  #include <stdio.h> 
  #include <stdlib.h> /* atoi() */ 
  #include "spin.h" 
   
  int main(int argc, char *argv[]) { 
    if(argc<2) { 
      fprintf(stderr, 
              "%s␣replication_factor␣<␣signal.float␣>␣signal.float\n", 
              argv[0]); 
      return 1; 
    } 
    { 
      int output_samples_per_input_sample = atoi(argv[1]); 
      for(;;) { 
        int i; 
        float input_sample; 
        fread(&input_sample,sizeof(float),1,stdin); 
        if(feof(stdin)) break; 
        for(i=0; i<output_samples_per_input_sample; i++) { 
          fwrite(&input_sample,sizeof(float),1,stdout); 
        } 
        spin(); 
      } 
      return 0; 
    } 
  }

  genera a partir de una entrada en binario otra salida en binario donde cada l’inea de entrada³ se va a repetir en la salida una determinado n’umero de veces.

• La biblioteca formada por los ficheros http://www.ace.ual.es/\~vruiz/redes/practicas/spin.h:
   
  /* 
   * spin.h -- Hace girar unas aspas. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/praticas/spin.h 
   * 
   * gse. 2006 
   */ 
   
  void spin();

  y http://www.ace.ual.es/\~vruiz/redes/practicas//spin.c:

   
  /* 
   * spin.c -- Hace girar unas aspas. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/praticas/spin.c 
   * 
   * Compilar escribiendo: 
   * gcc -c spin.c 
   * 
   * gse. 2006 
   */ 
   
  #include <stdio.h> 
  #include "spin.h" 
   
  static int angle = 0; 
   
  void spin() { 
    switch (angle) { 
    case 0: fprintf(stderr,"|\r"); break; 
    case 1: fprintf(stderr,"/\r"); break; 
    case 2: fprintf(stderr,"-\r"); break; 
    default: fprintf(stderr,"\\\r"); 
    } 
    angle = (angle+1)%4; 
  }

  sirve para calmar al usuario ansioso.

• En la entrada de sampler.c, cada n’umero real (representado f’isicamente como un n’umero en punto flotante de 32 bits de precisi’on) indica un estado de la señal.

8 Las cosas son m’as f’aciles con ...

• Para generar ficheros binarios a partir de entradas por teclado (en ASCII) y para visualizar el contenido de dichos ficheros binarios se han creado los programas http://www.ace.ual.es/\~vruiz/redes/practicas/ascii2float.c:
   
  /* 
   * ascii2float.c -- Genera un fichero de reales float a partir 
   *                  de otro en formato ASCII. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/practicas/ascii2float.c 
   * 
   * Compilar escribiendo: 
   * gcc ascii2float.c -o ascii2float spin.o 
   * 
   * gse. 2007 
   */ 
   
  #include <stdio.h> 
  #include "spin.h" 
   
  int main(int argc, char *argv[]) { 
    if(argc>1) { 
      fprintf(stderr,"%s < signal.txt > signal.float\n",argv[0]); 
      return 1; 
    } 
    for(;;) { 
      float x; 
      scanf("%f",&x); 
      if(feof(stdin)) break; 
      fwrite(&x,sizeof(float),1,stdout); 
      spin(); 
    } 
    return 0; 
  }

  y http://www.ace.ual.es/\~vruiz/redes/practicas/float2ascii.c:

   
  /* 
   * float2ascii.c -- Muestra un fichero de reales. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/practicas/float2ascii.c 
   * 
   * Compilar escribiendo: 
   * gcc float2ascii.c -o float2ascii spin.o 
   * 
   * gse. 2007 
   */ 
   
  #include <stdio.h> 
  #include "spin.h" 
   
  int main(int argc, char *argv[]) { 
    if(argc>1) { 
      fprintf(stderr,"%s < signal.float > signal.txt\n",argv[0]); 
      return 1; 
    } 
   
    for(;;) { 
      float x; 
      fread(&x,sizeof(float),1,stdin); 
      if(feof(stdin)) break; 
      printf("%f\n",x); 
      spin(); 
    } 
   
    return 0; 
  }
• Usando estos tres programas, podemos generar señales digitales digitalizadas y mostrarlas con el comando:
  ascii2float | sampler 2 | float2ascii

  Nota: el s’imbolo | redirige la salida est’andar del programa que queda a la izquierda sobre el programa que queda a la derecha.

9 El filtrado de señales

• Un filtro de señales es un sistema f’isico que modifica la potencia relativa de las distintas componentes de frecuencia de dichas señales [?]. En concreto, un filtro paso bajo es aquel que deja pasar las bajas frecuencias y elimina las altas, a partir de una determinada frecuencia f_c. En la siguiente figura podemos ver la funci’on de transferencia de un filtro paso bajo⁴ . A la frecuencia f_c se le conoce como frecuencia de corte (cut-off) del filtro.

  

• El programa http://www.ace.ual.es/\~vruiz/redes/practicas/low\_pass\_filter.c:
   
  /* 
   * low_pass_filter.c -- Filtro paso bajo. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/practicas/low_pass_filter.c 
   * 
   * Compilar escribiendo (el paquete fftw debera estar instalado!): 
   * gcc low_pass_filter.c spin.o -o low_pass_filter -lfftw3 -lm 
   * 
   * Ms informacin en: http/www.fftw.org 
   * 
   * gse. 2006 
   */ 
   
  #include <stdio.h> 
  #include <stdlib.h> 
  #include <math.h> 
  #include <fftw3.h> 
  #include "spin.h" 
   
  main(int argc, char *argv[]) { 
    if(argc < 2) { 
      fprintf(stderr, 
              "%s cut-off_band signal.float > filtered_signal.float\n" 
              ,argv[0]); 
    } else { 
   
      FILE *input_file = fopen(argv[2],"rb"); 
      if(!input_file) { 
        fprintf(stderr, 
                "%s: unable to open input file \"%s\"\n", 
                argv[0],argv[2]); 
        exit(1); 
      } 
   
      int samples = compute_number_of_samples(input_file); 
      fprintf(stderr,"%s: number of samples = %d\n",argv[0],samples); 
   
      double *signal = (double *)fftw_malloc(samples*sizeof(double)); 
      fftw_complex *spectrum = 
        (fftw_complex *)fftw_malloc(samples*sizeof(fftw_complex)); 
   
      /* Creamos un plan para la transformada directa e inversa */ 
      fftw_plan f = fftw_plan_dft_r2c_1d(samples, signal, spectrum, 0); 
      fftw_plan b = fftw_plan_dft_c2r_1d(samples, spectrum, signal, 0); 
   
      read_signal(signal, input_file, samples); 
   
      /* Calculamos la transformada de Fourier */ 
      fftw_execute(f); 
   
      filter_signal(spectrum, atof(argv[1]), samples, argv); 
   
      /* Calculamos la transformada de Fourier inversa */ 
      fftw_execute(b); 
   
      write_signal(signal, stdout, samples); 
   
      /* Destrumos los planes */ 
      fftw_destroy_plan(f); fftw_destroy_plan(b); 
   
      /* Liberamos memoria */ 
      free(spectrum); 
      free(signal); 
    } 
    return 0; 
  } 
   
  int compute_number_of_samples(FILE *input_file) { 
    fseek(input_file,0,SEEK_END); 
    int samples = ftell(input_file)/sizeof(float); 
    rewind(input_file); 
    return samples; 
  } 
   
  read_signal(double *signal, FILE *input_file, int samples) { 
    int i; 
    for(i=0; i<samples; i++) { 
      float x; 
      fread(&x,sizeof(float),1,input_file); 
      signal[i] = (double)x; 
      spin(); 
    } 
  } 
   
  write_signal(double *signal, FILE *output_file, int samples) { 
    int i; 
    for(i=0; i<samples; i++) { 
      float sample = signal[i]/samples; 
      fwrite(&sample,sizeof(float),1,output_file); 
      spin(); 
    } 
  } 
   
  filter_signal(fftw_complex *out, double factor, int samples, char **argv) { 
    int coefs_erased = 0; /* Coeficientes borrados */ 
    int i; 
    int fmax = samples/2; 
    int bandas_eliminadas = fmax*(1.0-factor); 
    for(i=fmax-bandas_eliminadas; i<fmax; i++) { 
      out[i][0] = out[i][1] = 0.0; 
      coefs_erased++; 
      spin(); 
    } 
    fprintf(stderr,"%s: number of erased Fourier coefficients = %d\n", 
            argv[0],coefs_erased); 
    fprintf(stderr,"%s: number of retained Fourier coeffcients = %d\n", 
            argv[0],samples/2-coefs_erased); 
  }

  permite filtrar una señal, dejando pasar la banda de frecuencias m’as bajas y eliminando el resto. Los par’ametros de este programa son:

  cut-off_band:

  es el ’indice, expresado como un n’umero real entre 0 y 1, de la banda de frecuencia m’as baja que es retenida (no eliminada). En general este par’ametro se calcula a partir de una frecuencia de corte f_c medida en Hz. Sea f_s la frecuencia de muestreo (n’umero de muestras por segundo) de la señal a filtrar (v’ease la Ec. 1). Seg’un el Teorema del Muestreo Uniforme, la m’axima componente de frecuencia de dicha señal NO puede ser superior a f_s∕2. Entonces se cumple que

  Supongamos, por ejemplo, que la señal digital transporta un bit de informaci’on por segundo. Si hemos tomado 32 muestras/bit, entonces tendremos f_s = 32 muestras/segundo y por tanto, estamos registrando hasta 16 Hz del espectro de dicha señal. Si queremos eliminar, por ejemplo, la banda de frecuencias que va desde 8 Hz a 16 Hz, es decir, aplicar un filtrado paso bajo, entonces

  

  señal.float:

  es un fichero que almacena la señal a filtrar. Puesto que estamos realizando los c’alculos en una m’aquina digital, las señales deben estar digitalizadas (muestreadas usando una frecuencia f_s de muestreo constante y cuantificadas utilizando un determinado n’umero de bits).

  señal_filtrada.float:

  fichero que almacena la señal filtrada. Tras el filtrado, la frecuencia de muestreo y el n’umero de bits por muestra son conservados. Por tanto, los ficheros señal_original.float y señal_filtrada.float deben tener el mismo tamaño.

• Como puede verse en el c’odigo de low_pass_filter.c, el algoritmo de filtrado consiste en pasar las muestras al dominio de Fourier, todas de una vez, eliminar los coeficientes de alta frecuencia, y devolver la señal al dominio del tiempo.

10 Filtrado de la señal “01”

• Comenzaremos filtrando una señal digital muy sencilla, una señal donde se transmite primero un bit a 0 y luego otro a 1, a una tasa de 1 bit por segundo. Los pasos a realizar est’an descritos en el script http://www.ace.ual.es/\~vruiz/redes/practicas/filtrado\_01.sh:
   
  #!/bin/bash 
   
  # 
  # Filtrado de la seal 01 
  # 
   
  # 
  # Creamos la seal 
  # 
  rm -f 01_signal.txt # Borramos el fichero 
  echo "-1.0" >> 01_signal.txt # El valor -1 representa el bit 0 
  echo "1.0" >> 01_signal.txt  # El valor 1 representa el bit 1 
  ascii2float < 01_signal.txt | sampler 128 > 01_signal.float 
   
  # 
  # Visualizamos su espectro 
  # 
  spectrum_analyzer 01_signal.float > 01_spectrum.txt 
  draw_signal.sh 01_spectrum.txt "Espectro␣de␣la␣seal␣01" 
   
  # 
  # filtramos la seal 
  # 
  low_pass_filter 0.5 01_signal.float > 01_filtered.float 
   
  # 
  # Visualizamos la seal filtrada 
  # 
  float2ascii < 01_filtered.float > 01_filtered.txt 
  draw_signal.sh 01_filtered.txt "Seal␣01␣filtrada" 
   
  # 
  # Visualizamos el espectro de la seal filtrada 
  # 
  spectrum_analyzer 01_filtered.float > 01_filtered_spectrum.txt 
  draw_signal.sh 01_filtered_spectrum.txt "Espectro␣de␣la␣seal␣01␣filtrada"
• En este script se utiliza el programa http://www.ace.ual.es/\~vruiz/redes/practicas/spectrum\_analyzer.c:
   
  /* 
   * spectrum_analyzer.c -- Analizador de espectros. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/redes/practicas/spectrum_analyzer.c 
   * 
   * Compilar escribiendo (el paquete fftw debera estar instalado!): 
   * gcc spectrum_analyzer.c -o spectrum_analyzer spin.o -lfftw3 -lm 
   * 
   * Ms informacin en: http/www.fftw.org 
   * 
   * gse. 2007 
   */ 
   
  #include <stdio.h> 
  #include <stdlib.h> 
  #include <math.h> 
  #include <fftw3.h> 
  #include "spin.h" 
   
  main(int argc, char *argv[]) { 
    if(argc < 2) { 
      fprintf(stderr,"%s input_signal.float > spectrum.txt\n",argv[0]); 
    } else { 
      FILE *input_file = fopen(argv[1],"rb"); 
      if(!input_file) { 
        fprintf(stderr,"%s: unable to open input file \"%s\"\n" 
                ,argv[0],argv[2]); 
        exit(1); 
      } 
   
      int samples = compute_number_of_samples(input_file); 
      fprintf(stderr,"%s: number of samples = %d\n",argv[0],samples); 
   
      double       *in  = (double       *)fftw_malloc(samples*sizeof(double      )); 
      fftw_complex *out = (fftw_complex *)fftw_malloc(samples*sizeof(fftw_complex)); 
   
      /* Creamos un plan para la fftw */ 
      fftw_plan p = fftw_plan_dft_r2c_1d(samples, in, out, 0); 
   
      read_signal(in, input_file, samples); 
   
      /* Calculamos la transformada de Fourier */ 
      fftw_execute(p); 
   
      /* Generamos el espectro de la seal */ { 
        int k; 
        for(k=0; k<samples/2; k++) { 
          double power_spectrum = sqrt(out[k][0]*out[k][0] + out[k][1]*out[k][1]); 
          fprintf(stdout,"%f\n",power_spectrum); 
        } 
      } 
   
      /* Destrumos el plan */ 
      fftw_destroy_plan(p); 
   
      /* Liberamos memoria */ 
      free(out); 
      free(in); 
    } 
    return 0; 
  } 
   
  int compute_number_of_samples(FILE *input_file) { 
    fseek(input_file,0,SEEK_END); 
    int samples = ftell(input_file)/sizeof(float); 
    rewind(input_file); 
    return samples; 
  } 
   
  read_signal(double *in, FILE *input_file, int samples) { 
    int i; 
    for(i=0; i<samples; i++) { 
      float x; 
      fread(&x,sizeof(float),1,input_file); 
      in[i] = (double)x; 
      spin(); 
    } 
  }

  que muestra una señal en el dominio de la frecuencia.

• Para visualizar las señales (tanto en el dominio del tiempo como en el de la frecuencia) podemos usar el script http://www.ace.ual.es/\~vruiz/redes/practicas/draw\_signal.sh:
   
  #!/bin/bash 
   
  # 
  # Visualiza una seal en formato ASCII almacenada en un fichero 
  # gse. 2006 
  # 
   
  function end { 
  #    (echo -e "" >&2) 
  #    (echo -n "ESC[1;0m" >&2) # ESC debe ser sustituido por el ASCII 27 
      exit 
  } 
   
  function help { 
  #    (echo -en "ESC[0;33m" >&2) # ESC debe ser sustituido por el ASCII 27 
      (echo -e "draw_signal␣signal.txt␣[title]" >&2) 
      (echo -e "" >&2) 
      (echo -e "␣␣signal␣=␣ASCII␣data␣file" >&2) 
      (echo -e "␣␣title␣=␣title␣of␣the␣graph" >&2) 
      (echo -e "" >&2) 
      (echo -e "␣␣Example:" >&2) 
      (echo -e "" >&2) 
      (echo -e "␣␣draw_signal␣signal.txt" >&2) 
      (echo -e "␣␣draw_signal␣signal.txt␣\"Seal ...\"" >&2) 
      end 
  } 
   
  if [ -z "$*" ]; then 
      help 
  fi 
   
  signal=$1 
  title=$2 
   
  if [ -z $signal ]; then 
    (echo -e "Sorry,␣missing␣the␣file␣name␣with␣the␣signal␣..." >&2) 
    end 
  fi 
   
  echo "set␣title␣\"$title\";\ 
  ␣plot␣\"$signal\"␣title␣\"\"␣with␣linespoints␣pt␣4␣ps␣0.5,\ 
  ␣\"$signal\"␣title␣\"\"␣with␣lines␣lt␣3" | gnuplot -persist
• Si todo ha ido bien deber’ia aparecerle una ventana con una curva semejante a la que se muestra en la Figura

  ---

  

  
  

  Figure 1: Recepci’on de la señal “01” a trav’es de un medio de transmisi’on que elimina las altas frecuencias.

  ---

  1.

11 Ahora un poco m’as dif’icil ...

1. Repita el ’ultimo experimento cuando se transmiten dos bits/segundo y eliminando todas las componentes de frecuencia por encima de 8 Hz (modifique el script filtrado_01.sh).
2. Conteste a las siguientes preguntas:

References