Contents

1 Introducci’on

• Existen situaciones donde un ’unico medio de transmisi’on debe ser compartido por varios emisores. En algunos casos, como ocurre en nuestras casas cuando estamos hablamos por tel’efono y a la vez descargamos datos de Internet, la multiplexaci’on permite usar un ’unico par de hilos met’alicos para ambas cosas al mismo tiempo, es decir, la multiplexaci’on abarata costes al no ser necesario tener que instalar dos pares. En otros casos, como cuando vamos en el coche escuchando una emisora de radio, no hay m’as remedio de multiplexar las señales ya que el medio de transmisi’on (el aire) es ’unico.

2 Multiplexaci’on de señales en el dominio del tiempo

• Dos (o m’as) señales pueden multiplexarse en el dominio del tiempo entrelazando sus muestras (siguiendo alg’un patr’on predefinido) y transmiti’endolas como si de una ’unica señal de se tratara. En la Figura

  ---

  
  

  Figure 1: Multiplexaci’on en el tiempo de dos señales limitadas en banda (f_m es la m’axima componente de frecuencia de cada una de ellas).

  ---

  1 se muestra un ejemplo de multiplexaci’on en el tiempo de dos señales en la que cada slot de tiempo transmite una muestra de cada señal. En este caso el patr’on de entrelazamiento es enviar s’olo una muestra de cada señal antes de enviar la siguente. N’otese que la tasa de datos de la señal resultante es el doble que la tasa de datos de cada una de las señales multiplexadas y que, por lo tanto, se necesita el doble de ancho de banda.

3 Multiplexaci’on de señales en el dominio de la frecuencia

• La alternativa a TDM (Time Division Multiplexing) es la multiplexaci’on en el dominio de la frecuencia o FDM (Frecuency Division Multiplexing). En este caso (como ocurre con las emisiones de radio) cada emisor transmite de forma continua en un rango de frecuencias diferentes. A cada una de estas bandas de frecuencias se les denomina canal de frecuencias o simplemente canal. Este proceso se describe para tres señales en la Figura

  ---

  
  

  Figure 2: Multiplexaci’on en la frecuencia de dos señales.

  ---

  2 donde ∗ denota a la convoluci’on entre señales y ⇒ a la modulaci’on de señales.

• En dicha figura w_a, w_b y w_c son los anchos de banda de tres señales a(t), b(t) y c(t), respectivamente. w_c1 y w_c2 son las frecuencias de dos señales portadoras (carrier) c₁(t) y c₂(t) que modulan a las señales b(t) y c(t), respectivamente. Si se cumple que w_c1 > w_a y que w_c2 > w_a + w_b es posible construir una señal s(t) como

  o lo que es lo mismo, construir S(f) como

  

  de la que es posible, m’as tarde, extraer las señales multiplexadas a(t), b(t) y c(t). Para ello hay que seleccionar el canal de frecuencias correspondiente y desmodular si es preciso.

4 Multiplexaci’on en la frecuencia de dos señales digitales

• Vamos a multiplexar y desmultiplexar en la frecuencia dos señales digitales. Lo primero que tenemos que tener en cuenta es que el espectro de las señales digitales no est’a limitado en banda. Por tanto, tendremos que filtrar ambas señales antes de multiplexarlas. En este ejemplo supondremos que vamos a transmitir dos señales a(t) y b(t) que transportan 16 bits cada una a una tasa de 2 bits/segundo y que el ancho de banda disponible es de 16 Hz. Dedicaremos, por tanto, 8 Hz a cada canal.
• A continuaci’on modularemos una de las señales (b(t), por ejemplo) utilizando una portadora de 8 Hz y sumaremos las dos señales. Por tanto, la operaci’on que estamos haciendo es

  donde c(t) es la señal portadora. En el dominio de la frecuencia estamos realizando el c’alculo

  

• Para recuperar cada señal (en su formato original) hay que seleccionar el canal de frecuencias correspondiente. En el caso de a(t) s’olo hay que aplicar un filtro paso bajo que seleccione el canal Hz. Con esto estamos eliminando B(f) ∗C(f) (o lo que es lo mismo b(t)c(t)) y no es necesario desmodular. Para la recuperar señal b(t) tendremos que eliminar la banda Hz con lo que eliminamos A(f) y a continuaci’on desmodular para obtenemer B(f).
• El script http://www.ace.ual.es/\~vruiz/redes/practicas/multiplexacion-desmultiplexacion.sh:
   
  #!/bin/bash 
   
  # 
  # Multiplexacin y desmultiplexacin de dos seales digitales 
  # 
   
  # 
  # Creamos la seal a(t) 
  # 
  rm -f a_signal.txt # Borramos el fichero 
  echo "-1.0" >> a_signal.txt # 1. El valor -1 representa el bit 0 
  echo "1.0" >> a_signal.txt  # 2. El valor  1 representa el bit 1 
  echo "1.0" >> a_signal.txt  # 3. 
  echo "1.0" >> a_signal.txt  # 4. 
  echo "-1.0" >> a_signal.txt # 5. 
  echo "-1.0" >> a_signal.txt # 6. 
  echo "-1.0" >> a_signal.txt # 7. 
  echo "1.0" >> a_signal.txt  # 8. 
  echo "1.0" >> a_signal.txt  # 9. 
  echo "1.0" >> a_signal.txt  # 10. 
  echo "-1.0" >> a_signal.txt # 11. 
  echo "-1.0" >> a_signal.txt # 12. 
  echo "1.0" >> a_signal.txt  # 13. 
  echo "-1.0" >> a_signal.txt # 14. 
  echo "-1.0" >> a_signal.txt # 15. 
  echo "-1.0" >> a_signal.txt # 16 
  ascii2float < a_signal.txt | sampler 128 > a_signal.float 
   
  # 
  # Creamos la seal b(t) 
  # 
  rm -f  b_signal.txt # Borramos el fichero 
  echo "1.0" >> b_signal.txt  # 1. El valor -1 representa el bit 0 
  echo "-1.0" >> b_signal.txt # 2. El valor  1 representa el bit 1 
  echo "-1.0" >> b_signal.txt # 3. 
  echo "1.0" >> b_signal.txt  # 4. 
  echo "-1.0" >> b_signal.txt # 5. 
  echo "-1.0" >> b_signal.txt # 6. 
  echo "-1.0" >> b_signal.txt # 7. 
  echo "1.0" >> b_signal.txt  # 8. 
  echo "-1.0" >> b_signal.txt # 9. 
  echo "1.0" >> b_signal.txt  # 10. 
  echo "-1.0" >> b_signal.txt # 11. 
  echo "1.0" >> b_signal.txt  # 12. 
  echo "1.0" >> b_signal.txt  # 13. 
  echo "1.0" >> b_signal.txt  # 14. 
  echo "-1.0" >> b_signal.txt # 15. 
  echo "1.0" >> b_signal.txt  # 16. 
  ascii2float < b_signal.txt | sampler 128 > b_signal.float 
   
  # 
  # Filtramos a(t). Transmite a una tasa de 2 bps y hay 128 muestras/bit. 
  # Por tanto, la frecuencia de muestreo es 256 muestras/segundo. 
  # Esto significa que la mxima componente de frecuencia registrada para a(t) 
  # es de 128 Hz. Como vamos a filtrar a 8 Hz, cut-off_band = 8/128 = 0.0625. 
  # 
  low_pass_filter 0.0625 a_signal.float > a_filtered_signal.float 
   
  # 
  # Lo mismo hacemos para b(t). 
  # 
  low_pass_filter 0.0625 b_signal.float > b_filtered_signal.float 
   
  # 
  # Modulamos la seal b(t) usando una portadora c(t). 
  # b(t) tiene un total de 128*16=2048 muestras 
  # y 2048/2=1024 bandas de frecuencia. Como el ancho de banda registrado es de 
  # 128 Hz, cada banda representa un total de 128/1024 = 0.125 Hz. Si queremos 
  # modular b(t) hasta los 8 Hz, 8/0.125=64 bandas. 
  # 
  modulator 64 b_filtered_signal.float > b_modulated_signal.float 
   
  # 
  # Sumamos s(t) = a(t) + c(t)b(t). 
  # 
  add a_filtered_signal.float b_modulated_signal.float > s_signal.float 
   
  # 
  # Visualizamos a(t) filtrada, b(t) filtrada y s(t). 
  # 
  float2ascii < a_filtered_signal.float > a_filtered_signal.txt 
  draw_signal.sh a_filtered_signal.txt "a(t)␣filtrada" 
  float2ascii < b_filtered_signal.float > b_filtered_signal.txt 
  draw_signal.sh b_filtered_signal.txt "b(t)␣filtrada" 
  float2ascii < s_signal.float > s_signal.txt 
  draw_signal.sh s_signal.txt "s(t)" 
   
  # 
  # Visualizamos A(f) filtrada, B(f) filtrada y S(f). 
  # 
  ./spectrum_analyzer a_filtered_signal.float > a_filtered_spectrum.txt 
  draw_signal.sh a_filtered_spectrum.txt "A(f)␣filtrada" 
  ./spectrum_analyzer b_filtered_signal.float > b_filtered_spectrum.txt 
  draw_signal.sh b_filtered_spectrum.txt "B(f)␣filtrada" 
  ./spectrum_analyzer s_signal.float > s_spectrum.txt 
  draw_signal.sh s_spectrum.txt "S(f)" 
   
  # 
  # Desmultiplexamos a(t). Eliminamos la banda de frecuencia 
  # ]8, 16] Hz. 
  # 
  low_pass_filter 0.0625 s_signal.float > a_desmultiplexed_signal.float 
   
  # 
  # Desmultiplexamos b(t). Filtramos y desmodulamos. 
  high_pass_filter 0.0625 s_signal.float > b_unmodulated_signal.float 
  demodulator 64 b_unmodulated_signal.float > b_desmultiplexed_signal.float 
   
  # 
  # Visualizamos a(t) desmultiplezada y b(t) desmultiplexada. 
  # 
  float2ascii < a_desmultiplexed_signal.float > a_desmultiplexed_signal.txt 
  draw_signal.sh a_desmultiplexed_signal.txt "a(t)␣desmultiplexada" 
  float2ascii < b_desmultiplexed_signal.float > b_desmultiplexed_signal.txt 
  draw_signal.sh b_desmultiplexed_signal.txt "b(t)␣desmultiplexada"

  realiza el proceso multiplexaci’on y desmultplexaci’on de dos señales digitales.

• El anterior script invoca adem’as a los programas http://www.ace.ual.es/\~vruiz/redes/practicas/modulator.c:
   
  /* 
   * modulator.c -- Modula una seal (desplaza su espectro). 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/docencia/redes/practicas/modulator.c 
   * 
   * Compilar escribiendo (el paquete fftw debera estar instalado!): 
   * gcc modulator.c -o modulator 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␣carrier_frequency␣unmodulated_signal.float␣>␣modulated_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)); 
      fftw_complex *tmp      = (fftw_complex *)fftw_malloc(samples*sizeof(fftw_complex)); 
   
      /* Creamos un plan para la transformada directa en 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); 
   
      modulate_spectrum(spectrum, tmp, samples, atoi(argv[1])); 
   
      /* 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(tmp); 
      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(); 
    } 
  } 
   
  modulate_spectrum(fftw_complex *spectrum, fftw_complex *tmp, int samples, int carrier) { 
    int i; 
    for(i=0; i<samples/2; i++) { 
      tmp[i][0] = 0; 
      tmp[i][1] = 0; 
      spin(); 
    } 
    for(i=0; i<samples/2 - carrier; i++) { 
      tmp[carrier+i][0] = spectrum[i][0]; 
      tmp[carrier+i][1] = spectrum[i][1]; 
      spin(); 
    } 
    for(i=0; i<samples/2; i++) { 
      spectrum[i][0] = tmp[i][0]; 
      spectrum[i][1] = tmp[i][1]; 
      spin(); 
    } 
  }

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

   
  /* 
   * add.c -- Suma dos seales. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/docencia/redes/practicas/add.c 
   * 
   * Compilar escribiendo: 
   * gcc add.c -o add spin.o 
   * 
   * gse. 2006 
   */ 
   
  #include <stdio.h> 
  #include <stdlib.h> 
  #include "spin.h" 
   
  char **_argv; 
   
  FILE* open_file(char *file_name) { 
    FILE *file_descriptor = fopen(file_name,"rb"); 
    if(!file_descriptor) { 
      fprintf(stderr,"%s:␣unable␣to␣open␣%s\n",_argv[0],file_name); 
      exit(1); 
    } 
    return file_descriptor; 
  } 
   
  main(int argc, char *argv[]) { 
    if(argc<3) { 
      fprintf(stderr,"%s␣signal_1.float␣signal_2.float␣>␣signal_1+2.float\n", 
              argv[0]); 
    } else { 
      _argv = argv; 
      FILE *s1,*s2; 
      s1 = open_file(argv[1]); 
      s2 = open_file(argv[2]); 
   
      int samples = 0; 
      for(;;) { 
        float sample1, sample2, add; 
        fread(&sample1,1,sizeof(float),s1); 
        if(feof(s1)) break; 
        fread(&sample2,1,sizeof(float),s2); 
        if(feof(s2)) break; 
        add = sample1 + sample2; 
        fwrite(&add,1,sizeof(float),stdout); 
        samples++; 
        spin(); 
      } 
      fprintf(stderr,"%s:␣number␣of␣samples␣=␣%d\n",argv[0],samples); 
    } 
    return 0; 
  }

  http://www.ace.ual.es/\~vruiz/redes/practicas/high\_pass\_filter.c:

   
  /* 
   * high_pass_filter.c -- Filtro paso alto. 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/docencia/redes/practicas/high_pass_filter.c 
   * 
   * Compilar escribiendo (el paquete fftw debera estar instalado!): 
   * gcc high_pass_filter.c -o high_pass_filter 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␣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 en 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*(factor); 
    for(i=0; i<bandas_eliminadas; 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); 
  }

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

   
  /* 
   * demodulator.c -- Desmodula una seal (desplaza su espectro). 
   * 
   * Este fichero fuente puede encontrarse en: 
   * http://www.ace.ual.es/~vruiz/docencia/redes/practicas/demodulator.c 
   * 
   * Compilar escribiendo (el paquete fftw debera estar instalado!): 
   * gcc demodulator.c -o demodulator 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␣carrier_frequency␣modulated_signal.float␣>␣unmodulated_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)); 
      fftw_complex *tmp      = (fftw_complex *)fftw_malloc(samples*sizeof(fftw_complex)); 
   
      /* Creamos un plan para la transformada directa en 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); 
   
      restore_spectrum(spectrum, tmp, samples, atoi(argv[1])); 
   
      /* 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(tmp); 
      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(); 
    } 
  } 
   
  restore_spectrum(fftw_complex *spectrum, fftw_complex *tmp, int samples, int carrier) { 
    int i; 
    for(i=0; i<samples/2; i++) { 
      tmp[i][0] = 0; 
      tmp[i][1] = 0; 
      spin(); 
    } 
    for(i=0; i<samples/2 - carrier; i++) { 
      tmp[i][0] = spectrum[carrier+i][0]; 
      tmp[i][1] = spectrum[carrier+i][1]; 
      spin(); 
    } 
    for(i=0; i<samples/2; i++) { 
      spectrum[i][0] = tmp[i][0]; 
      spectrum[i][1] = tmp[i][1]; 
      spin(); 
    } 
  }