Generación de señales de radiofrecuencia arbitrariassauron.etse.urv.es/public/PROPOSTES/pub/pdf/898pub.pdfGeneración de señales de radiofrecuencia arbitrarias TITULACIÓN: Ingeniería

Generación de señales de radiofrecuencia arbitrarias

TITULACIÓN: Ingeniería Técnica de Telecomunicaciones en Telemática

AUTORES: Álvaro Domínguez Baltasar DIRECTOR: Antonio Lázaro Guillén

FECHA: Septiembre / 2006.

Índice general

ÍNDICE GENERAL

Escuela Técnica Superior de Ingeniería Página 1

Índice general

1 MEMORIA DESCRIPTIVA............................................................................... Pág. 5

1.1 Hoja de identificación ......................................................................................... Pág. 6

1.1.1 Título del proyecto......................................................................................Pág. 6

1.1.2 Titular del proyecto.....................................................................................Pág. 6

1.2 Objetivos ............................................................................................................Pág. 6

1.3 Antecedentes........................................................................................................Pág. 7

1.4 Orden de documentación.....................................................................................Pág. 7

1.5 Idea del proyecto .................................................................................................Pág. 7

1.5.1 Esquema general .........................................................................................Pág. 7

1.5.2 Diseño, posibles soluciones y solución adoptada .......................................Pág. 9

1.5.3 Posibles aplicaciones ..................................................................................Pág. 10

1.6 Modulaciones digitales ........................................................................................ Pág. 11

1.6.1 Modulaciones analógicas y digitales .......................................................... Pág. 11

1.6.2 Visión teórica.............................................................................................. Pág. 11

1.6.3 Modulador I/Q ............................................................................................ Pág. 14

1.6.4 Demodulador I/Q ........................................................................................ Pág. 14

1.6.5 Modulaciones y diagramas I/Q................................................................... Pág. 15

1.6.5.1 ASK........................................................................................... Pág. 15

1.6.5.2 FSK............................................................................................ Pág. 16

1.6.5.3 BPSK......................................................................................... Pág. 17

1.6.5.4 QPSK......................................................................................... Pág. 18

1.6.5.5 Offset QPSK.............................................................................. Pág. 19

1.6.5.6 MSK .......................................................................................... Pág. 20

1.6.5.7 GMSK ....................................................................................... Pág. 22

1.6.5.8 M-QAM..................................................................................... Pág. 23

1.7 Síntesis de señales ............................................................................................... Pág. 24

1.7.1 Concepto ..................................................................................................... Pág. 24

1.7.2 Señal de audio............................................................................................. Pág. 24

1.7.3 Proyecto de Simulink.................................................................................. Pág. 25

1.7.4 Modulación y demodulación I/Q ................................................................ Pág. 29

1.7.5 Muestreo de ecuaciones .............................................................................. Pág. 32

1.8 Aplicación en C++ para el AM300 ..................................................................... Pág. 34


Índice general

1.9 Interfaz gráfica en Matlab ................................................................................... Pág. 35

1.9.1 Introducción................................................................................................ Pág. 35

1.9.2 E/S............................................................................................................... Pág. 36

1.10 Descripción........................................................................................................ Pág. 37

1.10.1 Instalación del software ............................................................................ Pág. 37

1.10.2 Descripción del hardware ......................................................................... Pág. 43

1.10.2.1 Introducción............................................................................. Pág. 43

1.10.2.2 Vista frontal............................................................................. Pág. 47

1.10.2.3 Vista posterior ......................................................................... Pág. 48

2 MEMORIA DE CÁLCULO................................................................................ Pág. 49

2.1 Aplicación AM300 .............................................................................................. Pág.50

2.2 Código interfaz gráfica en Matlab ....................................................................... Pág. 64

2.3 Adquisición de datos del FSP a través del GPIB................................................. Pág. 78

2.4 Fichero de configuración..................................................................................... Pág. 80

2.5 Fichero I/Q........................................................................................................... Pág. 81

2.6 Fichero de inicialización...................................................................................... Pág. 81

3 ANEXOS ............................................................................................................... Pág. 87

3.1 Anexo I: Bibliografía y direcciones de Internet .................................................. Pág. 88

3.2 Anexo II: Funciones de la librería Código en C++ ............................................. Pág. 89

3.2.1 Inicialización............................................................................................... Pág. 89

3.2.2 Configuración de canales............................................................................ Pág. 91

3.2.2.1 Configuración de la salida......................................................... Pág. 91

3.2.2.2 Configuración de acoplamiento de los canales ......................... Pág. 92

3.2.3 Configuración de parámetros...................................................................... Pág. 93

3.2.3.1 Frecuencia ................................................................................. Pág. 93

3.2.3.2 Amplitud.................................................................................... Pág. 94

3.2.3.3 Offset ......................................................................................... Pág. 95

3.2.4 Activar salida .............................................................................................. Pág. 96

3.2.5 Señales arbitrarias ....................................................................................... Pág. 97

3.2.5.1 Puntos ........................................................................................ Pág. 97

3.2.5.2 Inicio de lectura ......................................................................... Pág. 97


Índice general

3.2.5.3 Finalización de la lectura........................................................... Pág. 98

3.2.5.4 “Sample rate” ............................................................................ Pág. 99

3.2.5.5 “Rate mode” .............................................................................. Pág. 99

3.2.5.6 Carga de vectores en la memoria volátil I................................. Pág. 100

3.2.5.7 Carga de vectores en la memoria volátil II................................ Pág. 101

3.2.6 Cierre de conexión...................................................................................... Pág. 102

3.2.7 Errores......................................................................................................... Pág. 103

3.3 Anexo III: Guide de Matlab................................................................................. Pág. 104

3.3.1 Introducción................................................................................................ Pág. 104

3.3.2 Herramienta ................................................................................................ Pág. 105

3.3.3 Organización de objetos ............................................................................. Pág. 106

3.3.4 Almacenamiento de GUIs........................................................................... Pág. 108

3.3.5 Propiedades de objetos ............................................................................... Pág. 108

3.3.6 Estructura handles....................................................................................... Pág. 109


1. Memoria descriptiva

1. MEMORIA DESCRIPTIVA



1.1. Hoja de identificación 1.1.1. Título del proyecto

Generación de señales de radiofrecuencia arbitrarias. 1.1.2. Titular del proyecto El titular del proyecto es el Departamento de Ingeniería Eléctrica i Electrónica (DEEEA) situado en la avenida Países Catalanes núm. 26 de la ciudad de Tarragona, realizado por el Ingeniero Técnico en Telecomunicaciones, Álvaro Domínguez Baltasar, con representación del departamento el Dr. Antonio Ramón Lázaro Guillén.

1.2. Objetivos

El objetivo del proyecto es implementar un generador de señales arbitrario para modulación de señales digitales utilizando el generador de ondas arbitrarias de marca Rohde&Schwarz y modelo AM300. De este modo aprovecharíamos las librerías y controladores de este proveedor, para realizar nuestra propia aplicación, entre otras cosas se podría configurar y controlar dicho periférico, la principal utilidad seria la de enviarle un vector con una señal previamente sintetizada, este vector lógicamente estaría inicializado desde esta y más particularmente extraeremos los datos de un archivo realizado en cualquier otra aplicación (como podría ser Simulink), otras funciones que permite, son tales como:

- Generador de ondas “clásico” (cuadrada, triangular, ruido, exponencial, exponencial inversa, pulsos…)

- Modulación FM, AM, PM, FSK, PSK (realizado, pero a espera de mejoras de software).

En todos los casos los parámetros son tan configurables desde la interfaz de la cual dispone el periférico, como desde el lenguaje de programación y por tanto de nuestra aplicación. El periférico permite otras muchas opciones pero en principio estas son las que principalmente nos interesan.

Otro objetivo de este proyecto es de dotar al usuario, de una interfaz gráfica intuitiva para facilitar la interacción, a ser posible modificable y realizada sobre una aplicación potente matemáticamente, para el procesado de señales y datos (sintetizar señales evitando otra aplicación auxiliar).



Esta seria una visión muy general, pero hay muchos detalles que aquí no se comentan, pero que en los próximos apartados se empiezan a matizar, y que lógicamente tienen su razonamiento y su porque. 1.3. Antecedentes

Con la nueva titulación de ingeniería técnica en telecomunicaciones especialidad Telemática iniciada en 2003, por la propia escuela, se adquirieron diferentes materiales y componentes de comunicaciones, entre estos un modulador de señales I/Q con un buen potencial para generar señales, pero limitado a que debíamos introducir los valores de las señales a través del USB (con una memoria) utilizando un formato ya definido por aplicaciones de la casa Rohde&Schwarz , así pues para mejorar en gran medida su potencial, con este proyecto se ha conseguido principalmente enviar los datos a través de una aplicación realizada desde cero mediante el lenguaje C++ y utilizando una interfaz para el usuario en Matlab por cuestiones que se explicaran en los apartados siguientes. 1.4. Orden de documentación

Según la normativa de proyectos de la ETSE, la descomposición de los documentos tiene este orden: 1.- Memoria descriptiva 2.- Memoria de Cálculo 3.-Anexos 1.5. Idea del proyecto

En este apartado se describirá de forma más detallada el concepto del proyecto y cuales han sido las decisiones de diseño. Una vez explicada esta idea general, se introducirá a las modulaciones I/Q, que es parte esencial para los conocimientos teóricos.

1.5.1. Esquema general

A continuación se describe un esquema de bloques del proyecto, para facilitar el entendimiento, en el se destacan 5 bloques, los cuales se explicaran muy detalladamente en apartados posteriores.



Figura 1. Esquema general de la solución implementada en el proyecto

Ahora brevemente se describirá las funciones de cada bloque y como interactúan

entre ellos:

- Bloque 1: se trata de la conexión USB, desde el PC al periférico.

- Bloque 2: Programa realizado en Visual C++, es el que directamente se comunica con el periférico, utilizando sus funciones específicas, los datos introducidos están en un fichero de configuración, realizado por la interfaz gráfica.



- Bloque 3: Interfaz en Matlab, que será la que se encargará de tratar los

datos introducidos por el usuario, y generar el fichero de configuración, que posteriormente, el programa en C++ necesitará para realizar las acciones pertinentes.

- Bloque 4: Sintetizado de una señal cualquiera (explicado en el apartado

de señales I/Q), así pues desde un archivo de un formato preestablecido, se cargará en 2 vectores (para los canales I/Q), y se introducen dentro de la memoria temporal del periférico, este último reconstruirá la señal con unos parámetros determinados por los respectivos canales 1 y 2. Este archivo simplemente debe contener los valores de los muestreos, así pues cualquier aplicación externa desde la cual se puedan extraer muestras, servirá (ej. Simulink).

- Bloque 5: El periférico en si, de Rohde&Schwarz modelo AM300, con el cual se basa todo el proyecto, por tanto es necesario describir algunas especificaciones técnicas, además de sus funcionalidades y de la interfaz de usuario (Botones, pantalla, opciones, conexiones…) de forma muy general.

1.5.2. Diseño, posibles soluciones y solución adoptada

• La primera decisión fue el lenguaje de programación para comunicarse vía USB con el periférico:

Las posibilidades de programación que ofrecía modelo AM-300 de ROHDE&SCHWARZ, son las siguientes: - Visual C/C++ - Visual Basic - National Instruments LabView - National Instruments LabWindows/CVI - AgilentVEE

La elección del lenguaje ha sido Visual C/C++ por su sencillez de uso, y porque el proveedor daba más información para acceder a sus funciones. Así pues utilizaremos para programar la herramienta Microsoft Visual Studio C++ 6.0.

• La segunda opción que había que barajar, era la interacción con el usuario, es decir, como este introduciría sus datos, y se optó por realizar evidentemente una sencilla interfaz. También se pensó en realizarla en C/C++, pero era una limitación en cuanto a un programa potente matemáticamente como Matlab y con el cual se podrían realizar diferentes acciones en tiempo real. Cabe decir que Matlab permite ejecutar dlls y exes de forma sencilla (con un signo de exclamación delante, en la consola de Matlab).



• Otra toma de decisión fue como realizar la interacción entre la interfaz y el

programa en C (que es con el que verdaderamente se comunica con el periférico).Se pensó primero en utilizar unas librerías de Matlab que permitían compartir datos al programa en C, pero esto se hacia complicado cuando se necesitaban bastantes parámetros, así pues, se decidió utilizar un fichero intermedio que generaría la interfaz y por otra parte captaría dicho programa en C.

• Respecto a la interfaz en Matlab, primero se optó por realizar diferentes

ventanas, pero finalmente, pensando en el diseño más sencillo, útil, accesible y robusto, se creo una única ventana en la cual se pueden introducir los parámetros y donde también se muestra una breve descripción de cada uno. La primera vía era muy complicada, tanto para programarla (comunicación entre ventanas) como para el usuario (demasiadas acciones para fijar parámetros).

• Respecto al fichero donde se almacenan los datos de las señales muestreadas, el

formato debe ser el siguiente:

o 2 columnas, la primera para muestreos del canal I, y la segunda para los canales Q.

o Deben ser enteros entre -16383 y 16383, que es la escala permitida a la hora de mandar la orden, respecto al número de puntos, la escala de nivel y la frecuencia de salida, se configura a través de la interfaz gráfica.

1.5.3. Posibles aplicaciones

• Una aplicación, es la de utilizarlo como un generador de funciones. • Sintetizar una señal con un determinado programa, y cargar esos datos para los

canales I/Q, ya que esta modulación es sencilla y muy versátil. • Posteriormente si queremos aumentar considerablemente la frecuencia,

utilizaremos un mezclador como el SM300 también de Rhode&Schwarz, con el cual podremos llegar hasta 3GHz.

• Resaltar que ha sido un proyecto realizado desde cero, con las complicaciones que comporta saber utilizar las herramientas y las librerías que necesitamos, en este mismo, están explicados todos los pasos para empezar a programar a través del bus USB. Comentar por otro lado que es un proyecto mejorable y ampliable en el futuro, pudiendo así realizar cualquier tipo de señal, puesto que las librerías han dado bastantes problemas y en el caso de las modulaciones ni han llegado a funcionar, en un futuro (periférico con un año y medio de antigüedad) estas se mejoraran y se les podrá sacar todo el partido.



1.6. Modulaciones digitales

En este apartado se describe brevemente la generación de señales digitales mediante modulación fase/cuadratura o IQ. Se introducirán conceptos genéricos de que es una modulación, algunos tipos de modulaciones y se relacionará con su modulación en I/Q. 1.6.1. Modulaciones analógicas y digitales

La modulación consiste en modificar en función de la señal modulada, la amplitud, la fase, o la frecuencia de una portadora de frecuencia mucho mayor que la señal moduladora, donde reside la información a transmitir (ver Figura 2).

Figura 2. Ecuación de onda

Si se piensan los posibles parámetros a modificar de la ecuación anterior, estos están limitados a cambios de amplitud, de frecuencia y de fase, para codificar la información. 1.6.2. Visión teórica

Se trata de una modulación muy utilizada en circuitos integrados de equipos de comunicaciones modernos. Esta modulación consiste en utilizar dos canales, que varían la fase y la amplitud de una portadora senoidal. En el diseño de ICs de moduladores I/Q, las características principales serán:

- Rendimiento y precisión. - Distorsión. - Consumo. - Eficiencia. - Rango dinámico.



- Potencia de salida.

A continuación se describirá, en el contexto de modulaciones digitales el significado del diagrama I/Q:

Figura 3. Descripción de un diagrama I/Q

El diagrama I/Q consiste en representar para cada BIT la componente en fase (eje x) y la componente en cuadratura (eje y).

⎟⎟⎠

⎞⎜⎜⎝

⎛⎟⎟⎠

⎞⎜⎜⎝

⎛++=+=

)()(tancos)()()sin()()cos()()( 0

2200 tI

tQarttQtIttQttItv ωωω

(1)

Comentar de la ecuación anterior, que la función I(t) esta acompañada de un coseno (fase 0º) y que la función Q(t) en este caso esta acompañada por un seno (fase 90º).

También se puede representar en módulo y con la fase ( )artan( )

Q tI t

⎛ ⎞⎜ ⎟⎝ ⎠

.

En la figura siguiente se representa lo que hemos comentado de los dos canales I/Q, con su modulo y fase.

I

Q

I

Q



Figura 4. Figura de una señal en I/Q

Cabe comentar, que si pensamos en modulaciones en general sabemos que la

frecuencia es simplemente el índice del cambio de la fase de una onda del seno (la frecuencia es el primer derivado de la fase), así que estos componentes de la ecuación de onda del seno se pueden referir colectivamente como el ángulo de la fase. Por lo tanto, podemos representar el estado instantáneo de una onda del seno con un vector en el plano complejo que contiene la magnitud (amplitud) y la fase coordina en un sistema coordinado polar. Con un ejemplo práctico una onda del seno con una frecuencia de 1 hertzio (2π radianes/sec) rotará a la izquierda alrededor del origen en un índice de una revolución por segundo. Si la amplitud es sin cambios durante este tiempo, nos podemos imaginar un círculo alrededor del origen con el radio igual la magnitud a lo largo de los cuales el punto viajará en un índice de un ciclo por segundo.

En las modulaciones puede haber cambios de amplitud, de fase, de ambas o de frecuencia, y esto se ve reflejado en el plano I/Q de la forma siguiente:

Figura 5. Representación de diferentes cambios en un diagrama I/Q



1.6.3. Modulador I/Q

El esquema de un modulador de una señal cualquiera, utilizando el concepto I/Q explicado anteriormente, corresponde a la figura posterior. En la entrada hay una ráfaga de bits en serie, por lo tanto después es necesario un bloque conversor a paralelo, que distribuye la información a cada canal (en la práctica un bloque llamado decisor, distribuye los bits para cada canal), el canal que vendrá a ser el I, se retrasa un Ts, se conforma mediante un filtro conformador de nivel, y finalmente se multiplica por Acos(w0t) (canal en fase), por otra parte el canal Q sigue el mismo proceso, pero en este caso estará esta multiplicado por Asen(w0t) (canal en cuadratura). En último lugar los canales I y Q se suman y dan lugar a la señal de salida V(t). Todo este proceso esta plasmado en la figura posterior:

Figura 6. Representa esquema conceptual de un modulador I/Q

v(t) A.Cos (w0t)

Conformador Nivel

Conformador Nivel

π/2

Retardo Tb

S/P

I(t)

Q(t) A.Sen (w0t)

{Bits}

1.6.4. Demodulador I/Q En este apartado se describe como se demodula de la señal previamente modulada en I/Q.

Conformador Nivel

π/2V(t)

Conformador Nivel

I(t)

Q(t)

Figura 7. Representa esquema conceptual de un demodulador I/Q



.6.5. Modulaciones y diagramas I/Q

.6.5.1. ASK (Amplitude Shift Keying)

e trata de una modulación digital de amplitud binaria. Al no haber fase, la señal será:

(2)

La señal esta escalada en función del tiempo normalizado t/Tb, sabiendo que h(t) es

e V(t), de una modulación ASK

Al tratarse de una modulación únicamente en amplitud y la fase no es cambiante, los pun

Figura 9. Diagrama I/Q de una señal ASK

1 1 S

⎩⎨⎧

=⎭⎬⎫

⎩⎨⎧

−= ∑ "0"0"1"1

);cos()()( 0 sisi

dcontwkTthdAtv kk

Tk

un impulso, el sumatorio de impulsos retardados T segundos entre si, conformados por kd y multiplicados por un factor de escala A, nos da como resultado todo lo que multiplica al coseno. Se puede observar más detalladamente en la figura siguiente, donde la señal en azul representa kd y la roja la señal total V (t).

Figura 8. Señal kd

tos sobre el diagrama I/Q se sitúan sobre el eje real, como se puede observar a continuación:

“1“0

0

1

0 V(t)

“0

“1

-



1.6.5.2. FSK (Frequency Shift Keying)

e trata de una modulación digital en frecuencia, la función de la cual es la siguiente: S

( )[ ] { } TtdcondtftwAtv kkd ≤≤±+= 01;2cos)( 0 π ε (3)

Dentro del coseno el

( ) kd dtfπ2 , donde puede tener los valores , es eviden ión en fr

)()( 0 (4)

Representando la señal en función de un tiempo normalizado t/Tb, donde la

señal a

kd 1±te que al ser una modulac ecuencia y no en fase, pues tiene la variable t

multiplicando.La frecuencia total del coseno será pues:

∑ −+=k

Tkdi kTtrectdfftf

zul es la de origen y la roja después de modular, por otra parte, anotar que en nivel alto la frecuencia es de dff +0 y en nivel bajo es dff −0 .

Figura 10. Señal origen y modulada en FSK

a figura siguiente por otra parte, muestra el uso de 2 frecuencias para transmitir

LInformación:

Figura 11. Diagrama I/Q de una señal FSK

-1 0 1

f0-fd

“1” “0” “0” “1” “1” “1” “0” “0” “1” “0” f0+fd

Umbral

“1

“0

f1

f2



1.6.5.3. BPSK (BiPhase Shift Keying)

s una modulación digital en fase binaria.

a función es la siguiente:

⎩⎨ ∑

"0"10"1"11

)()(cos) 00

k

kk

kTk

kTk

dsidsi

con

TKthtwAtw

ϕ

ϕ

(5)

La señal en azul es la que se pretende modular, la característica de esta modula

lo antes

Figura 12. Se trata de la señal origen y el resultado de su modulación BPSK

continuación se describe el diagrama I/Q de una señal QPSK, los valores oscilan en el

Figura 13. Diagrama I/Q de una señal BPSK

E L

⎩⎨⎧

⇒−≡⇒≡

=

−+=⎭⎬⎫⎧

−= ∑ cos()()( kTthdAtv

ción es que cambia de fase 180º, cada vez que hay un cambio de valor. En la figura posterior se observa detalladamente dicha modulación, y comentado del cambio de fase:

1

0 V(t)

“0”

“1”

-

Aeje real positivo (0º) y el negativo (180º), como se puede observar:

“1“0”



1.6.5.4. QPSK (Quadrature Phase Shift Keying)

e trata de una modulación digital de fase cuaternaria. Se puede observar que esta

kTko

+=

=⎭⎬⎫

⎩⎨⎧

−•+= ∑ ϕ

(6)

ambién se puede ver de la siguiente manera (separando la parte real e imaginaria de

);(Im)(

;)(Re)(

(7)

continuación en la figura se mostrará un ejemplo de secuencia modulada en QPSK

Smodulación se desglosa en una función I(t) en fase y otra Q(t) de fase 90º.

)()()cos()(

)()cos()(

00 twsentQtwtI

kTthtwAtv

T

kd ):

{ }

{ }∑

∑−•=

−•=

kTk

kTk

kTthdagtQ

kTthdaltI

A(siendo importante la señal total modulada V(t)):

Figura 14. Figura de los canales I/Q y de la señal total (dependiete de la secuencia) de una modulación QPSK

0 -1

0

1

I(t)

Q(t)

“10 “01 “11 “00 “10

V(t)



Esta modulación es más complicada que las anteriores, así pues, describiré para cada fase el valor en canales I/Q:

( ) { }( ) {( ) {( ) { }⎪

⎪⎩

⎪⎪⎨

⎧

⇒−=⇒−−=⇒+−=⇒+=

=

"0","1"1º315"0","0"1º225"1","0"1º135

"1","1"1º45

simbolojdsisimbolojdsisimbolojdsi

simbolojdsi

k

k

k

k

kϕ}}

(“1”,”1”)

(8)

El cálculo anterior traducido al diagrama I/Q da como resultado la figura siguiente:

Figura 15. Diagrama I/Q de QPSK

(“0”,”1”)

1.6.5.5. Offset QPSK

Se trata de una modulación digital de fase cuaternaria, pero que en este caso se retrasa Tb segundos, para evitar los pasos por cero.

Se observa entonces, que las formulas son las mismas excepto por un retardo:

;))12(()(

;)2()(:

);()()cos()()(

12

2

00

∑

∑+−•=

−•=

+=

+k

bTk

kbTk

TktrectdAtQ

kTtrectdAtIcon

twsentQtwtItv

(9)

En una visión temporal de los canales I/Q, se retrasa el canal en cuadratura, y así no se pasa por 0 (evitando problemas en el emisor) :

(“0’”,”0”) (“1”,”0”)



“10 “01 “11 “00 “10

Figura 16. Canales I/Q y resultado de la modulación

Como ya se ha mencionado se evita el paso por cero, esto se puede observar en el diagrama I/Q y se trata de la única diferencia respecto a la QPSK normal:

Figura 17. Diagrama I/Q de una señal Offset-QPSK

1.6.5.6. MSK (Minimum Shift Keying) Es una Offset-QPSK pero con pulso conformador senoidal (reducimos las posibilidades de ISI, eliminando discontinuidades de fase). Las funciones que se describirán a continuación, son exactamente iguales a la anterior

modulación, pero multiplicadas por ⎟⎠

⎞⎜⎝

⎛T

tπcos que es el pulso conformador.

∑

∑

⎟⎠⎞

⎜⎝⎛⋅+−⋅=

⎟⎠⎞

⎜⎝⎛⋅−⋅=

+=

+k

bTk

kbTk

TtsenTktrectdAtQ

TtkTtrectdAtI

twsentQtwtItv

π

π

))12(()(

;cos)2()(

)()()cos()()(

12

2

00

(10)

0 -1

0

1

V(t)

I(t)

Q(t)

(“0”,”1”)

(“0’”,”0”) (“1”,”0”)

(“1”,”1”)



El pulso conformador “suaviza” los niveles, reduciendo así la posibilidad de ISI (al no ser tan abrupto) debido a errores de sincronización.

Aquí se muestra el pulso conformador, en este caso se trata de un coseno ( ⎟⎠⎞

⎜⎝⎛

Ttπcos )

Figura 18. Pulso conformador

Es una modulación algo más complicada, pero acotada en un tiempo normalizado como siempre. A continuación se describen los canales, y su señal total:

Figura 19. Canales I/Q y señal modulada La ventaja de la MSK es que al ser uniforme, no hay problemas de errores

debido a saturación (compresión igualitaria), porque el modulador al generar los símbolos, utiliza para todos la misma potencia.

Como en los casos anteriores, se realiza a continuación una descripción de la

T/2 t -T/2

P(t)

0

I(t)

Q(t)

V(t)

“0” “0” “0” “0” “0” “0” “0” “1” “1” “1”

modulación, utilizando el diagrama de canales I/Q:



Figura 20. Canales I/Q en una modulación MSK

.6.5.7. GMSK (Gaussian Minimum Shift Keying)

e trata de una modulación MSK, pero con premodulación (Gaussiano) de los símbolos

Figura 21. Comparación de señales MSK y GMSK

n referencia al diagrama I/Q es muy similar al de MSK:

1 Spara mejorar las propiedades espectrales. En la figura posterior, se observa que no hay cambios abruptos (que requieren frecuencias altas) y así de esta manera se necesita menos espectro para transmitir, y en definitiva se obtiene mejor eficiencia espectral.

E

GGMMSSKK

t

fMMSSKK

t

f

f0+fd f0+fd

f0-fd f0-



Figura 22. Diagrama I/Q de una modulación GMSK

1.6.5.8. M-QAM Se trata de una modulación digital de amplitud y fase. Dentro de las señales digitales esta en concreto, se trata de una modulación de símbolos. Como siempre se puede desglosar en canales I/Q:

)()()cos()()( 00 twsentQtwtItv +== (11) La secuencia a modular, se puede distribuir en parte real que irá en el canal I y una parte imaginaria en el Q:

{ } { }

{ ...4,3,2,1)12()12(

)(Im)(;)(Re)(

=−±−±=

−•=−•= ∑∑

qqjqd

kTthdagtQkTthdaltI

k

kTk

kTk

(12)

Debido a que es una modulación en amplitud y fase, y seria complicado ver el diagrama temporal, directamente se mostrará el plano I/Q.



Figura 23. Diagrama I/Q de una modulación QAM

1.7. Síntesis de señales 1.7.1. Concepto

En los siguientes apartados veremos como realizar el sintetizado de los canales

con todas sus aplicaciones prácticas, en estos únicamente realizaremos el fichero con el formato específico, esta será la única variación, por último y de forma exactamente igual en todos los casos, cargaremos los vectores utilizando la interfaz gráfica de Matlab. 1.7.2. Señal de audio

A continuación explicaremos como extraer datos de un archivo de audio, en este caso utilizaremos uno de formato WAV, la escalaremos y crearemos el fichero con los datos que luego enviaremos al periférico:

[x,fs]=wavread('Exit.wav'); t=1:70000; x=x(t); sound(x,fs); x=x*10000; plot(t,x); A=round([x',x']); save salidaaudio.txt A -ascii;

Código 1. Código de acceso a un archivo WAB

Destacar que el wavread extrae x y fs, donde la primera variable son los datos y la segunda la frecuencia de muestreo en Hz, de la señal de audio. Así pues extraeríamos los datos de la variable x a un fichero, que posteriormente seleccionaremos con la interfaz gráfica. Como utilizaremos un único canal, se puede utilizar el que se quiera. La salida del “plot” de los datos podría tener una forma como la siguiente:



Figura 24. Onda de audio 1.7.3. Proyecto de Simulink

A continuación se explicará otro método para extraer los canales I/Q, lo que realizamos en este ejemplo es un emisor y un receptor con una comunicación M-FSK, se puede comentar que no se han introducido cada uno de los bloques, pero el principal bloque es “To Workspace”, que permite guardar datos de la salida, así pues nos crea una estructura (lo tenemos que configurar) de números reales e imaginarios, que desglosaremos en canales I/Q (real/imaginario).

Figura 25. Ejemplo de proyecto

El sistema de la figura anterior, utiliza una modulación QPSK con un filtro coseno, y un canal con un buen SNR (que afecta poco al resultado final), mencionar



que al final del sistema hay un diagrama del ojo y como antes hemos comentado, un bloque que permite adquirir los datos.

A continuación está el código al cual nos referimos, este desglosa en canales I/Q y lo guarda en un archivo con el formato: columna I y columna Q.

Figura 26. Configuración del bloque, que permite guardar datos en el Workspace

Como se puede observar, se simula el tiempo realizando un array de 1 a 2048, se extraen los datos que serán número complejos, que por lo tanto deberemos distribuir al canal pertinente, qc será el canal Q (cuadratura) y el ic el canal I (fase).

a=1:2048; datos=salida.signals.values; qc=imag(datos(a))*16000; ic=real(datos(a))*16000; A=round([ic,qc]); save canalesiq.txt A –ascii

Código 2. Extracción de datos de un bloque de Simulink

El fichero I/Q posteriormente se selecciona con la interfaz gráfica, se configura la velocidad de muestreo y el número de puntos, y se acepta, enviando así al periférico estos vectores, que va extrayendo (de la memoria volátil) a sus respectivos canales.

Hemos realizado dos ejemplos de una modulación QPSK, en el primer caso utilizamos un canal con 30dB de SNR y en el segundo caso de 5dB (para demodular correctamente una QPSK, es necesario unos 7dB de SNR), por otra parte tenemos que



el factor de escala establecido es de 1V, y hemos utilizado un filtro conformador de 0,3 de rolloff1 en ambos casos.

A continuación se muestran, tanto el canal 1 como el canal 2, que hemos conectado al osciloscopio y que representan el canal I y el canal Q respectivamente. Utiliza una modulación con 8 niveles, resaltar que hemos utilizado vectores de 2048 puntos, a una frecuencia de: frecuencia deseada/8 (debido a que es una modulación multinivel y estamos hablando de la frecuencia de BIT).

Figura 27. Canales I/Q con la señal, con un canal de SNR de 30dB

A continuación observamos la misma señal, pero en este caso con ruido (menos SNR de simulación en el medio de transmisión), de esta forma observamos que ha perdido mucha calidad.

1 El coeficiente Roll off es un parámetro de diseño del filtro. Cuando el Roll off tiene a cero se acorta la banda y se tiende al filtrado ideal. El valor máximo posible es uno. Generalmente se indica el valor del Roll off como un número (típico 0,2 a 0,7) o un porcentaje (20 a 70%).



Figura 28. Canales I/Q con canal de SNR de 5dB

Por otra parte hemos observado el ancho de banda con un analizador de espectros, y hemos capturado el caso óptimo (el caso pesimista espectralmente, no se aprecia la diferencia).

Figura 29. Figura de ancho de banda de una QPSK

Así pues con la figura anterior podemos observar como afecta al espectro dicha modulación, cabe comentar que esta centrada a 1GHz, que es la frecuencia en la que trabaja el SM300, este elemento se explicará en el apartado siguiente.



1.7.4. Modulación y demodulación IQ

Llegamos al punto de poder modular una señal I/Q y posteriormente demodularla, pero para esto realizamos el montaje mostrado en la figura siguiente:

AM300 SM300 FSP

Control USB

Canal I Señal modulada

Canal Q

USBTarjeta

USB/GPIB

GPIB

Figura 30. Montaje para modulación/demodulación, I/Q Los pasos y la función de cada bloque se describirán a continuación:

• Computadora:

Este elemento nos permitirá sintetizar una señal y guardar esos datos en un archivo, hemos creído conveniente utilizar Simulink de Matlab para realizar esta operación, así pues podemos realizar cualquier sistema de transmisión con las únicas limitaciones del propio programa. Hemos creído conveniente para esta prueba una señal QPSK, ya que permite “juego” con los dos canales. Los parámetros son los siguientes: Rollof de 0.3, fsampling=100kHz.y por último utilizando 2048 puntos.

( ) { }( ) {( ) {( ) { }⎪

⎪⎩

⎪⎪⎨

⎧

⇒−=⇒−−=⇒+−=⇒+=

=

"0","1"1º315"0","0"1º225"1","0"1º135

"1","1"1º45

simbolojdsisimbolojdsisimbolojdsi

simbolojdsi

k

k

k

k

kϕ}}



A parte podremos realizar el control del AM300 mediante la interfaz realizada en Matlab y el propio programa en C, de esta forma enviaremos los valores de los dos canales al AM300 y este generará esos valores físicamente.

• AM300: Como se ha descrito a lo largo del proyecto, genera señales aleatorias I/Q a partir

de unos valores introducidos.

• SM300:

Se trata de un modulador que permite trabajar a altas frecuencias (3GHz) en las cuales el AM300 no funciona correctamente. Teniendo los canales I/Q, si quisiéramos aumentar mucho la frecuencia, deberíamos utilizar este modulador I/Q para que mezclase los dos canales, en este caso utilizaremos el SM300 de Rohde&Schwarz, el cual permite frecuencias hasta de 3GHz, la salida (canales mezclados) seria el RFout. Su esquema conceptual seria el siguiente:

Figura 31. Esquema/interfaz del SM300

• FSP:

Es un analizador de espectros muy completo y entre otras utilidades permite demodular una señal I/Q y posteriormente adquirir estos datos a través de GPIB (librerías de Matlab) gracias a esto por ejemplo se puede reconstruir los dos canales y dibujar la constelación de lo que se recibe. Los principales parámetros configurados son la frecuencia a 1GHz y un “Sweep Time” de 5ms. Los canales reconstruidos son los mostrados a continuación:



0 1 2 3 4 5-0.1

0

0.1

t(ms)I C

Han

nel(V

)

0 1 2 3 4 5-0.1

0

0.1

t(ms)

Q C

Han

nel(V

)

Figura 32. Canales I/Q

A continuación mostramos la constelación de la señal QPSK, como se puede observar en la salida, la constelación va rotando (debido a desincronizaciones), esta velocidad de rotación se trata de la desincronización respecto a los diferentes elementos del sistema que hemos realizado, hemos intentado sincronizar estos dispositivos empleando las señales de entrada y salida de sincronismo (trigger/gate) de los diferentes dispositivos, pero aun así es necesario realizar un ajuste mucho más exacto para poder visualizar correctamente la constelación. De esta manera los datos (Diagrama I/Q) que extraemos del FSP son los siguientes:

-0.1 -0.05 0 0.05 0.1-0.1

-0.05

0

0.05

0.1

I Channel (V)

Q C

hann

el (V

)

Figura 33. Constelación I/Q de una QPSK



Como se puede observar, la constelación ideal de una QPSK tiene 4 puntos formando un cuadrado, en los cuales se observa las transiciones de los diferentes símbolos:

-1.5 -1 -0.5 0 0.5 1 1.5

x 104

-2

-1.5

-1

-0.5

0

0.5

1

1.5x 104

Figura 34. Constelación ideal antes de modular

1.7.5. Muestreo de ecuaciones

En este apartado lo que haremos es a partir de ecuaciones sencillas, muestrearlas y realizar el fichero de configuración. Como tenemos dos canales podremos enviar una función distinta por cada uno de ellos:

t=linspace(-T0/2,T0/2,2048); Ts=(t(2)-t(1)); fs=1/Ts f0=5e3;T0=1/f0 c=10000*sin(2*pi*f0*t); a=1:2048;a=a-1024; b=16000*sinc(4*2*pi*a/1024); A=round([b',c']); save salida.txt A -ascii;

Código 3. Funciones sintetizadas

Simplemente b y c son funciones cualquiera muestreadas por el array a (numero de puntos) y con estos datos creamos el fichero, en la seno hemos sintetizado exactamente un periodo y la sinc la hemos adelantado (a=a-1024) para así mostrar también la parte negativa (simétrica). Si lo seleccionamos con la interfaz gráfica, la salida real de los dos canales será la siguiente:



En primer lugar observar que por el primer canal se ha generado la forma de

onda de un seno:

Figura 35. Canal I En este caso se muestra el segundo canal, en el cual se observa la sinc claramente:

Figura 36. Canal Q



1.8. Aplicación en C++ para el AM300

Hemos elegido el Visual C++ porque es el que mejores librerías y documentación ofrecía, a parte de que es un lenguaje potente, conocido, extensible y se puede encontrar mucha documentación sobre él, el único defecto que se le podría achacar es que utiliza funciones muy específicas. Simplemente mostraremos por capas, donde se situaría una aplicación en C++, evidentemente se situaría arriba del todo, como se observa a continuación:

Figura 37. Diagrama de flujo de una aplicación de Windows



1.9. Interfaz gráfica en Matlab 1.9.1. Introducción

Destacar que se ha utilizado Matlab debido a su potencial matemático, y en nuestro caso particular, por la posibilidad de muestrear señales, y desglosarlas en canales I/Q, en este caso podemos utilizar simplemente el Terminal de Matlab (funciones) o si se desea realizar algo más real, utilizar Simulink para efectuar sistemas más complejos, pudiendo configurar: emisor, canal receptor, modulación, datos, ruido, interferencias etc., todo esto se verá en el apartado de Simulink donde se explicará como extraer datos a una variable, y de esta a un fichero, que adquirirá el programa en C y enviará al periférico. Así pues describiremos toda la interfaz gráfica realizada en Matlab, sus ficheros .m y su estructura, de forma muy generalizada, sin entrar mucho en el código, pues esto se introducirá en otro apartado.

Realizaremos la interfaz gráfica utilizando la herramienta GUIDE de Matlab, que nos genera el esqueleto con los eventos de los diferentes elementos de esta, que lógicamente después programaremos, para esto utilizaremos diferentes ficheros .m que cargarán las variables necesarias para inicializar la interfaz y establecer valores por defecto, pues si no inicializásemos algunas variables, posteriormente el periférico podría tener algún tipo de problema. Para entender mejor la estructura de programación, observar el esquema siguiente:

Figura 38. Diagrama de bloques de la interfaz gráfica en Matlab La idea pues es la siguiente:



1. Se cargan los parámetros, utilizando el fichero.m, este contiene las configuraciones por defecto de todas las variables (globales), por lo tanto las inicializa (valor, unidad y descripción), es evidente que aprovechamos que Matlab permite el uso de estructuras en árbol2 que se realizan de forma sencilla, sobretodo en este caso que hay muchos parámetros y debemos de cargar sus descripciones en la interfaz. 2 Un vez el usuario ha introducido todos los datos, se genera el archivo de configuración, y se ejecuta3 el programa en C. 1.9.2. E/S

En el proyecto se hacen tres operaciones en particular de entrada y salida, la primera es mostrar una imagen a través de un axes4, realizar el fichero de configuración y la tercera copiar un fichero que contiene los datos I/Q en la ruta donde se sitúa el programa en C.

axes(handles.imagen); handles.imagen=imread('irovira.bmp'); imagesc(handles.imagen); axis off;

Código 4. Código de inserción de una imagen en un axes

A continuación se observa el código de generación del archivo de configuración, que utiliza fopen para manejo de archivos y fprintf para “imprimir” en este. Se imprime el vector parámetros que contiene un identificador y un valor, en cada posición (contiene toda la configuración).

fp=fopen('configuracion.txt','w'); i=1; while(i<=length(parametros)) a=char(parametros(i).n); fprintf(fp,'%s\t',a); a=char(parametros(i).v); fprintf(fp,'%s\t',a); i=i+1; % end end fclose(fp)

Código 5. Código de creación del archivo de configuración 2 Ejemplo: variable1.datos.descripción, de esta manera podemos guardar y cargar datos en estas variables, siendo mucho más sencilla la realización del programa. 3 En Matlab simplemente deberemos introducir un signo de exclamación más el .exe en cuestión 4 Es un eje de coordenadas que permite dibujar gráficos e imágenes



Se describe a continuación, la copia de un archivo, en la ruta donde se ubica el programa en C (utilizamos una función de Matlab, donde el usuario accede al fichero que se desea copiar). entrada=fopen(direccion,'r'); salida=fopen('canalesiq.txt','w'); dato='a'; a=''; while strcmp(dato,'')~=1 dato=fscanf(entrada,'%c',1); fprintf(salida,'%c',dato); end Código 6. Código de copia de un archivo en la ruta actual

1.10. Descripción 1.10.1. Instalación del software En apartado se describirá la instalación/configuración de herramientas y componentes necesarios para poder realizar el control del AM300 a través del programa realizado en C. 1. Instalación de Microsoft Visual Studio C++ 6.0: que en principio no debe dar ningún problema, pues solamente necesitamos el compilador y la ayuda de esta herramienta, sin necesidad de librerías muy específicas ni otras herramientas suplementarias. 2. Instalación de LabVIEW 6.0: pues necesitamos instalar la aplicación VISA y algunas de sus librerías de control que en un futuro podrían ser necesarias. 3. VXI Plug&Play Instrument Driver: se trata de un “package” de controladores, DLLs, LIBs e “Includes”, además drivers USB necesarios para el control remoto desde un ordenador. 4. LabView: Librerías necesarias para el VXIplug&play. 5. LabWindows/CVI (rssiam.cvi): Contiene todas las “C sources”5. El contenido de este archivo .zip:

5 Se trata de todos los elementos necesarios para poder programar en el lenguaje C, son archivos: .lib, .def, .dll, .h etc.



rssiam.h - Fichero de cabecera para C, HP VEE and LabView/LabWindows. rssiam.c - Código fuente. rssiam.def - Archivo de definición para C++ para generar los dlls. rssiam.fp - Function Panel para HP VEE and LabVIEW/LabWindows rssiam.bas - Módulo para usar Visual BASIC rssiam.vb - Módulo para usar con .NET BASIC rssiam.hlp - Fichero de ayuda para VB rssiam.chm - HTML comprimido de ayuda para C y Visual Basic. rssiam.lib - Librería para C++. rssiam_32.dll - “Dynamic Link Library” para usar para todas las plataformas. instrsup.dll - “Instrument support Dynamic Link Library” para LabWindows/CVI. SiControl.dll - “Dynamic Link Library file” para usar para todas las plataformas. SiControl.lib - Librería para usar con C/C++. SiControl.h - Fichero de cabecera para usar con C y LabWindows. rssitype.h - Fichero de cabecera para C y LabWindows (VISA data types). rssi.inf - RSSI (USB I/O) Setup Information file rssi.sys - RSSI (USB I/O) Controlador. readme.txt - Archivo que contiene información en general. license.pdf - Información de la licencia. SiTools - Set of device management utilities

6 Instalar el CD del proveedor, que incluye entre otras la herramienta Series 300 Software Manager. 7 Instalación de Matlab 6.0.

• Estructura: La estructura de directorios, después de haber realizado la instalación del software anterior, es la siguiente:

Figura 39. Estructura de directorios del software Debido a que esta instalado el VISA, se deberá acceder al subdirectorio WinNT, que contendrá:



Directorio Contenido \bin DLLs (e.g. rssiam_32.dll) \lib Librerías (e.g.rssiam.lib) \bc (Borland C) \msc

(Microfsoft C que será nuestro caso)

\include Ficheros de cabecera -rssitype.h (declaraciones de “Smart

Instruments” para C) -SiControl.h (declaraciones en C) -rssiam.h (Funciones para el A300 para C) -rssiam.bas (Funciones para Visual Basic)

\Kbase Vacío por defecto \rssiam -license.pdf

-readme.txt -rssiam.c -rssiam.chm -rssiam.def -rssiam.fp -RSSIFS.HLP

\GWinNT

LabView files - rssiam.chm (HTML based Help) - rssiam_xx.mnu (ficheros LabView) - rssiam.llb (librería LabView)

Tabla 1. Estructura de directorios del software

• Uso de librerías: Para utilizar librerías estas deben estar integradas dentro del proyecto, por esta razón accederemos al menú: “Project->Project Settings->Link "Object/Library Modules", y enlazaremos la librería rssiam.lib, introduciéndola dentro de: “Object/library modules”, dejando por supuesto las que venían por defecto.



Figura 40. Opciones del proyecto Hemos introducido las librerías, pero aun falta indicar el “path”, y lo haremos de la manera siguiente, Tools->Options..->Directory, así pues introduciremos todos los “paths”, donde tengamos librerías, “includes”, ficheros de origen o ejecutables, mediante la pestaña “Show directories for”. Para mejor entendimiento:

Figura 41. Configuración de los enlaces de “Includes” (ficheros .h)



Figura 42. Configuración de los enlaces de librerías (ficheros .lib) Una vez realizados todos los pasos anteriores, sería posible crear el proyecto con la herramienta Microsoft Visual Studio C++ 6.0.

• Herramienta SiScan: Tenemos todo lo necesario para poder programar, pero la primera vez necesitaremos registrar el AM300, para esto, se realizaran los pasos siguientes: Se conectará el AM300 a través de USB a la computadora en cuestión, ejecutamos la herramienta “Series 300 Software Manager” (instalado en el paso 6 del anterior apartado) donde entre otros posibles dispositivos aparecerá el AM300, con su dirección USB (necesaria para empezar a programar), así pues introduciremos el nº de registro y clave (dado por el proveedor) y ya tendremos acceso a la interfaz USB y al AM300 para establecer la comunicación.



. Figura 43. Dispositivos en el programa SiScan

• Proyecto: El último paso es realizar el proyecto en si. Crearemos de esta forma el código de inicio, imprescindible para utilizar las funciones de acceso al AM300:

//Todos los “includes” a cabeceras #include "stdafx.h" #include <stdio.h> //Fichero de cabecera am300 #include <rssiam.h> #include <rssitype.h> #include <math.h> #include "string.h"

//Dirección USB6 para acceder al AM300

ViRsrc resourceName = "USB::0x0AAD::0x0005::100119";

//Abre sesión, inicializa, resetea y retorna el instrumentHandle Status=rssiam_init (resourceName, VI_TRUE, VI_TRUE,&instrumentHandle);

Código 7. Comandos de inicio necesarios Una vez inicializado utilizaríamos el instrumentHandle (puntero al AM300), para ejecutar cualquier instrucción posible, como se explicará en el apartado de programación.

6 La dirección USB se compone de: Id. Vendedor(VID) + Id. Instrumento (PID) + Número de serie



1.10.2. Descripción del hardware 1.10.2.1. Introducción El AM300 se trata de un generador de doble canal, capaz de producir por ambos canales tanto señales arbitrarias, como funciones normales. Ofrece en la práctica señales potentes con poca distorsión. Tiene una velocidad de 100MS/s y 256k de memoria, para introducir los puntos de una señal, esta utilidad es la que nos sirve para enviar una señal sintetizada al periférico.

• Principales características:

o Dos canales de funcionamiento independiente (pero se pueden acoplar), que permiten seleccionar la forma de onda, frecuencia y amplitud.

o 0,01º de resolución. o Supresión de armónicos para señales sinodales (1MHz) típicamente

70dB. o Buena referencia en frecuencia, 1ppm/año. o “Jitter-free clock” de 50MHz o Interfaz USB, para memorias USB. o Ondas: seno, triangular, cuadrada, exponencial, ruido y pulso. o Rango de frecuencias: 35Mhz para seno y 50Mhz para cuadradas. o Modulaciones: AM, FM, φM, FSK, PSK o Posibilidad de uso de un teclado para facilitar la entrada de datos. o Control remoto a través de USB, que permite comunicarse con el PC,

que es el objetivo de este proyecto.

• A continuación se muestran los límites respecto a la frecuencia, de las diferentes formas de onda.

Tabla 2. Límites frecuenciales

• Respecto a límites de voltaje hay que tener en cuenta, a la hora de configurar cualquier señal que hay ciertos límites:



Figura 44. Limitaciones de voltaje respecto el DC

• Simplemente se muestra los parámetros principales de una señal, en este caso una señal triangular.

Figura 45. Algunos parámetros de una señal



• La fase viene determinada por la frecuencia establecida, por esta razón se establecen unos límites de frecuencias:

.Figura 46. Resolución en función de la frecuencia

• Cuando configuramos los dos canales, estos tienen diferentes limitaciones como: o Siempre combinados. o Combinados solo si el acoplamiento en frecuencia está desactivado. o Combinados solo si el acoplamiento en frecuencia está activado.

La figura de la página siguiente muestra las combinaciones de los dos canales, respecto al tipo de configuración de cada uno de ellos:



Figura 47. Configuración de los canales



1.10.2.2. Vista frontal A continuación se muestra una imagen del dispositivo, se describirán de manera muy genérica la función de cada tecla:

Figura 48. Vista frontal del AM300

1 Conmutador ON/STANDBY 8 Señal de salida CH1 (BNC connector) 2 Indicador ON/STANDBY 9 Señal de salida CH2 (BNC connector) 3 Tecla SYS 10 Tecla de unidades 4 Tecla ESC/CANCEL 11 Joystick 5 ENTER 12 Teclas numéricas 6 Teclas de cursor 13 Teclas de funciones 7 Teclas de cursor 14 Pantalla



1.10.2.3. Vista posterior Ahora se muestra una imagen en este caso una trasera:

Figura 49. Vista posterior del AM300

15 Salida para señal filtrada de CH1 24 Conector de monitor 16 Entrada de señal filtrada de CH2 25 Conector de teclado 17 Entrada para referencia 26 Entrada para “trigger/gate” externo 18 Salida para entrada/salida de referencia 27 Salida para señal sync de CH2 19 Conector externo USB 28 Salida para sync de CH2 20 Conector USB para periféricos 29 Salida para señal filtrada de CH1 21 AC conector de corriente 30 Entrada para señal filtrada de CH1 22 AC fusible 23 Interruptor


2. Memoria de cálculo

2. MEMORIA DE CÁLCULO



2.1. Aplicación AM300

A continuación introduzco el código en C++ de la aplicación que propiamente es la que se comunica y controla el periférico, en este caso el AM300: /********************************************************************/ /* @file AM300_Basic_Measurement.cpp @copyright (c) Rohde & Schwarz GmbH & Co. KG, Munich @version 1.0 @language C++ (maybe C also) *********************************************************************/ #include "stdafx.h" #include <stdio.h> //libreria del am300 #include <rssiam.h> #include <rssitype.h> #include <math.h> #include <string.h> //Libreria para el manejo de ficheros #include <fstream.h> #include <iostream.h> #include <windows.h> #include <string.h> /* incloure definicions de funcions propies */ ViRsrc resourceName = "USB::0x0AAD::0x0005::100119"; //"Analyser1"; ViSession instrumentHandle; /* VISA instrument handle */ ViStatus Status=0; /* VISA status */ ViChar message[256]; * VISA message buffer */ ViInt16 canali[20000]; ViInt16 canalq[20000]; ViReal64 param[512]; ViReal64 amplitudeDepth=50; ViReal64 referenceLevel =-10; /* Reference Level : -27 dBm */ ViInt32 frequencyParameter =0; /* Frequency Parameter : 0 - Start And Stop */ ViReal64 startFrequency =10e6; /* Start Frequency : 10 MHz */ ViReal64 stopFrequency =30e6; /* Stop Frequency : 30 MHz */ ViInt32 resolutionBandwidth =0;



/* Resolution Bandwidth : 0 - Auto */ ViInt32 videoBandwidth =0; /* Video Bandwidth : 0 - Auto */ ViReal64 bandWidth =0; /* Bandwidth reading value */ ViInt32 sweepPoints =100; /* Number of Sweep Points per Trace */ ViReal64 _VI_FAR traceData[2048]; /* Trace Data Buffer */ ViInt32 samplesReturned =0; /* Samples returned form the FS300 */ ViInt16 funcion=0; ViReal64 frecuencia =1e3; ViReal64 amplitud =3; ViReal64 offset =0; ViInt16 canalactivo =1; ViInt16 channelCoupling =0; ViInt32 dataPoints =0; ViInt32 dataStart =0; ViInt32 dataStop =0; ViReal64 dataSampleRate =0; ViInt32 noofPoints =0; ViReal64 dataArray[1000]; FILE *file_esc; FILE *file_lec; /*================================================================*/ /* Function: lectura() */ /* Purpose: Realiza la lectura del fichero, y lo guarda em el

vector param

/*==================================================================*/ int lectura(){ FILE *fichero; char nombre[20] = "configuracion.txt"; unsigned int i; float x1; char str [80]; fichero = fopen( nombre, "r" ); printf( "Fichero: %s (para lectura) -> ", nombre ); if( fichero ){ printf( "existe (ABIERTO)\n" ); } else { printf( "Error (NO ABIERTO)\n" ); return -1; } printf( "Datos leidos del fichero: %s\n", nombre );



for( i=0; i<=20; i++ ) { if (!feof(fichero)){ fscanf (fichero, "%s", str); printf ("He leido: %s \n",str); fscanf( fichero,"%f\t", &x1); param[i]=x1; printf( "Valores: ""%f\n", x1);} } if( !fclose(fichero) ){ printf( "Fichero cerrado\n" ); return 0; } else { return -1; printf( "Error: fichero NO CERRADO\n"); } } /*==================================================================*/ /* Function: void Error_Message(ViStatus Status) */ /* Purpose: imprime errores visa y del periférico por la pantalla */ /* Parameter: ViStatus Status /* Return: nada */ /*==================================================================*/ void Error_Message(ViStatus Status) { if(Status){ /* display device/driver errors */ printf("(Error Code: 0x%x)",Status); Status= rssiam_error_message (instrumentHandle, Status, &message[0]); Status= rssiam_error_query (instrumentHandle, &Status, &message[0]); printf(&message[0]); printf("\n"); } }



/*==================================================================*/ /* Function: void Volt2dBm(ViReal64 Volt) */ /* Purpose: Pasa de Voltios a dBm */ /* Parameter: ViReal64 Volt - Voltage Level */ /* Return: ViReal64 - dBm Level */ /*==================================================================*/ ViReal64 Volt2dBm(ViReal64 Volt) { return(10*log10((pow(Volt,2)/(50*0.001)))); } /*==================================================================*/ /* Function: ini() */ /* Purpose: Activamos un canal y desacoplamos ambos canales /*==================================================================*/ int ini(){ if(lectura()==-1){ return -1; } //Abre sesión con el aparato, resetea (coge estado nuevo), retorna el instrumentHandle Status=rssiam_init (resourceName, VI_TRUE, VI_TRUE,&instrumentHandle); //Controlamos si se ha establecido la comunicación Error_Message(Status); if (Status){ printf("\nPeriférico no conectado\n"); //IMPORTANTE, LO QUITAMOS PARA QUE SE SIGA EJECUTANDO return(-1); } else if(!Status) printf("\nPeriférico conectado\n"); //Desacoplamos los dos canales (Por defecto estan acoplados en f) channelCoupling=0; Status=rssiam_outpChannelCoupl (instrumentHandle,channelCoupling); Error_Message(Status); return 0;



} /*===========================================================*/ /* Function: predet() */ /* Purpose: Configura una señal predeterminada /*==================================================================*/ void predet(){ ViReal64 amplitud; funcion=(ViInt16)param[1]; amplitud=(ViReal64)param[2]; frecuencia=(ViReal64)param[3]; offset=(ViReal64)param[4]; printf("Funcion %i ",funcion); printf("Voltage %f ",amplitud); printf("Frecuencia %f ",frecuencia); printf("Offset %f ",offset); Status=rssiam_appl(instrumentHandle,funcion, frecuencia,amplitud,offset); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); Error_Message(Status); } /*==================================================================*/ /* Function: am() */ /* Purpose: Configura una modulación en amplitud AM /*================================================================*/ void am(){ ViReal64 indice=(ViReal64)param[2]; ViInt16 funcion=(ViInt16)param[3]; ViReal64 frecuencia=(ViReal64)param[4]; printf("Indice %f ",indice); printf("funcion %i ",funcion); printf("frecuencia %f ",frecuencia); Status=rssiam_amDept (instrumentHandle, indice);



Error_Message(Status); Status=rssiam_amIntFunc (instrumentHandle, funcion); Error_Message(Status); Status=rssiam_amIntFreq (instrumentHandle, frecuencia); Error_Message(Status); Status=rssiam_amState (instrumentHandle,(ViInt16)1); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); Error_Message(Status); } /*==================================================================*/ /* Function: fm() */ /* Purpose: Configura una modulación en frecuencia FM /*==================================================================*/ void fm(){ ViReal64 desviacion=(ViReal64)param[2]; ViInt16 funcion=(ViInt16)param[3]; ViReal64 frecuencia=(ViReal64)param[4]; printf("Desviacion %f ",desviacion); printf("Funcion %i ",funcion); printf("Frecuencia %f ",frecuencia); Status=rssiam_fmDev (instrumentHandle, desviacion); Error_Message(Status); Status=rssiam_fmIntFunc (instrumentHandle,funcion); Error_Message(Status); Status=rssiam_fmIntFreq (instrumentHandle,frecuencia); Error_Message(Status); Status=rssiam_fmStat (instrumentHandle, 1); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); Error_Message(Status); } /*===============================================================*/ /* Function: fsk() */ /* Purpose: Configura una modulación FSK



/*=================================================================*/ void fsk(){ ViReal64 frecuencia=(ViReal64)param[2]; ViReal64 frecuencia2=(ViReal64)param[3]; printf("SaltoF %f ",frecuencia); printf("Frecuencia2 %f ",frecuencia2); Status=rssiam_fskFreq (instrumentHandle,frecuencia); Error_Message(Status); Status=rssiam_fskIntRate (instrumentHandle,frecuencia2); Error_Message(Status); Status=rssiam_fskSour (instrumentHandle, 0); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); Error_Message(Status); } /*==============================================================*/ /* Function: moduladas() */ /* Purpose: Menu de señales moduladas /*==================================================================*/ void moduladas(){ int op2; op2=(ViInt16)param[1]; switch(op2) { case 0 : printf("Moduladas opcion AM: %i\n",op2); am(); break; case 1 : printf("Moduladas opcion FM: %i\n",op2); fm(); break;



case 2 : printf("Moduladas opcion FSK: %i\n",op2); fsk(); break; case 3 : printf("Moduladas opcion: %i\n",op2); break; default : printf("Moduladas opcion: %i\n",op2); } } /*==================================================================*/ /* Function: cargariq() */ /* Purpose: Se cargan los datos I/Q en los vectores canal[i] y canal[q] respectivamente /*==================================================================*/ void cargariq(){ FILE *fichero; char nombre[] = "canalesiq.txt"; unsigned int i,a; float x1,x2; fichero = fopen(nombre, "r" ); printf( "Fichero: %s (para lectura) -> ", nombre); if( fichero ){ printf( "existe (ABIERTO)\n" ); } else { printf( "Error (NO ABIERTO)\n" ); } printf( "Datos leidos del fichero: %s\n",nombre); a=1; for( i=0; i<=param[2]; i++ ) { if (!feof(fichero)){



fscanf (fichero, "%f", &x1); fscanf (fichero, "%f ", &x2); //printf ("He leido I: %f \t",x1); //printf ("Envio I: %f \n",x1); //printf ("Envio Q: %f \n",x2); canali[i]=(ViReal64)x1; canalq[i]=(ViReal64)x2; a=1; } } if( !fclose(fichero) ){ printf( "Fichero cerrado\n" ); } else { printf( "Error: fichero NO CERRADO\n"); } } /*==================================================================*/ /* Function: canaliq() */ /* Purpose: Envia los canales I/Q a través de los vectores al AM300 /*==================================================================*/ void canaliq(){ ViReal64 frecuencia; ViInt32 npuntos; ViReal64 voltaje; frecuencia=(ViReal64)param[1]; printf("Frecuencia de muestreo %f ",frecuencia); npuntos=(ViInt32)param[2]; printf("Numero de puntos %i ",(ViInt32)param[2]); voltaje=(ViReal64)param[3]; printf("Escala de voltaje %f ",voltaje); frecuencia=frecuencia/npuntos; int a; int b; b=0; //Podemos cargar los vectores de forma manual para comprovar el buen funcionamiento



/* for(a=0;a<1024;a=a+1){ canali[a]=10*a; if(a>512){ canali[a]=0; } } */ Status=rssiam_outpChannel (instrumentHandle,1); printf("STATUS %i ",Status); Error_Message(Status); //Establecemos una escala para el intervalo [-1,1] Status=rssiam_volt (instrumentHandle, voltaje); printf("STATUS %i ",Status); Error_Message(Status); rssiam_voltOffs (instrumentHandle ,0); printf("STATUS %i ",Status); Error_Message(Status); //Fijamos la forma de onda en la opción usuario, //necesario para la ejecución de la siguiente funcion Status=rssiam_funcShap (instrumentHandle, 6); printf("STATUS %i ",Status); Error_Message(Status); //Fijamos la el sample en accurate Status=rssiam_dataArbRateMode (instrumentHandle, 0); printf("STATUS %i ",Status); Error_Message(Status); Status= rssiam_freq (instrumentHandle,frecuencia); printf("STATUS %i ",Status); Error_Message(Status); /* //Inicio de lectura de datos (util para leer fragmentos) dataStart=0; Status=rssiam_dataArbStart (instrumentHandle,dataStart); printf("STATUS %i ",Status); Error_Message(Status); //Finalización de lectura de datos dataStop=npuntos; Status=rssiam_dataArbStop (instrumentHandle,dataStop); printf("STATUS %i ",Status); Error_Message(Status); Status=rssiam_dataArbPoin (instrumentHandle, npuntos);



printf("STATUS %i ",Status); Error_Message(Status); */ Status=rssiam_dataDacVolatile (instrumentHandle,npuntos,canali); printf("STATUS %i ",Status); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); printf("STATUS %i ",Status); Error_Message(Status); ////////////////////////////////////////////////////////////////////// Status=rssiam_outpChannel (instrumentHandle,2); printf("STATUS %i ",Status); Error_Message(Status); //Establecemos una escala para el intervalo [-1,1] Status=rssiam_volt (instrumentHandle, voltaje); printf("STATUS %i ",Status); Error_Message(Status); rssiam_voltOffs (instrumentHandle ,0); Error_Message(Status); printf("STATUS %i ",Status); Error_Message(Status); //Fijamos la forma de onda en la opción usuario, //necesario para la ejecución de la siguiente funcion Status=rssiam_funcShap (instrumentHandle, 6); printf("STATUS %i ",Status); Error_Message(Status); //Fijamos la el sample en accurate Status=rssiam_dataArbRateMode (instrumentHandle, 0); printf("STATUS %i ",Status); Error_Message(Status); Status= rssiam_freq (instrumentHandle,frecuencia); printf("STATUS %i ",Status); Error_Message(Status); /* //Inicio de lectura de datos (util para leer fragmentos) dataStart=0; Status=rssiam_dataArbStart (instrumentHandle,dataStart); printf("STATUS %i ",Status); Error_Message(Status); //Finalización de lectura de datos



dataStop=npuntos; Status=rssiam_dataArbStop (instrumentHandle,dataStop); printf("STATUS %i ",Status); Error_Message(Status); Status=rssiam_dataArbPoin (instrumentHandle, npuntos); printf("STATUS %i ",Status); Error_Message(Status); */ //Misma explicación que el caso anterior /* for(a=0;a<512;a=a+1){ canalq[a]=10*a; if(a>300){ canalq[a]=-1111*sin(a*100); } }*/ Status=rssiam_dataDacVolatile (instrumentHandle,npuntos,canalq); printf("STATUS %i ",Status); Error_Message(Status); //Activamos la salida Status=rssiam_outpSetup (instrumentHandle,1); printf("STATUS %i ",Status); Error_Message(Status); } /*==================================================================*/ /* Function: menu() */ /* Purpose: Función que envia una de las señales predeterminadas /*==================================================================*/ void menu(){ int op1; op1=(ViInt16)param[0]; switch(op1) { case 0 : printf("Eligio opcion %i\n",op1);



predet(); break; case 1 : printf("Eligio opcion %i\n",op1); moduladas(); break; case 2 : printf("Eligio opcion %i\n",op1); cargariq(); canaliq(); break; case 3 : printf("Eligio opcion %i\n",op1); break; default : printf("Opcion %i\n incorrecta",op1); } } /*==================================================================*/ /* Function: int main(void) */ /* Purpose: inicialización */ /* Parameter: */ /* Return: 0 si no hay error */ /* -1 si hay error */ /*=================================================================*/ int main(void) { if(ini()==-1){ return -1; } menu();



//Cerramos comunicación Status=rssiam_close (instrumentHandle); Error_Message(Status); return(0); } return(0); }



2.2. Código interfaz de Matlab En este apartado introduciré propiamente el código Matlab, de la interfaz gráfica. Esta contiene diferentes elementos, los cuales contienen eventos que debemos controlar según el caso. A continuación mostraré el aspecto de esta y los diferentes componentes, relacionándolos con sus “Tags”, que son las etiquetas mediante las cuales accederemos a las propiedades de cada uno de estos (objetos en la estructura handles).

menu

Menu 2

Lista

Parametro Unidades

Boton fijar

Descripción

Descripción 2

Boton Cancelar

Boton Acptar

Figura 50. Interfaz gráfica de Matlab

En principio la interfaz gráfica parece sencilla, pero hay muchos elementos y dependencias entre ellos, por no mencionar si utilizamos más de una ventana (comunicación entre ventanas) que aún se complicaría todo mucho más.

Los elementos se van activando de forma secuencial, así de esta manera el usuario no puede introducir parámetros, sin haber previamente seleccionado alguna opción, evitando así muchos problemas. El botón fijar servirá para ir introduciendo valores con su escala respectiva. Otra parte importante es la de cargar valores por defecto, es decir, que aunque el usuario no introduzca parámetros, estos estarán cargados por defecto. Por otra parte destacar que cuando accionemos el botón aceptar, se creará el archivo de configuración y se arrancará el programa en C (debemos de mirar antes si el usuario a introducido datos o se han cargado por defecto).



El código de la interfaz gráfica es el siguiente: function varargout = am300(varargin) % AM300 M-file for am300.fig % AM300, by itself, creates a new AM300 or raises the existing % singleton*. % % H = AM300 returns the handle to a new AM300 or the handle to % the existing singleton*. % % AM300('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in AM300.M with the given input arguments. % % AM300('Property','Value',...) creates a new AM300 or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before am300_OpeningFunction gets called. An % unrecognized property name or invalid value makes property application % stop. All inputs are passed to am300_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Copyright 2002-2003 The MathWorks, Inc. % Edit the above text to modify the response to help am300 % Last Modified by GUIDE v2.5 22-Aug-2006 18:19:21 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @am300_OpeningFcn, ... 'gui_OutputFcn', @am300_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT



% --- Executes just before am300 is made visible. function am300_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to am300 (see VARARGIN) % Choose default command line output for am300 handles.output = hObject; %handles % Update handles structure guidata(hObject, handles); % UIWAIT makes am300 wait for user response (see UIRESUME) % uiwait(handles.figure1); axes(handles.imagen); handles.imagen=imread('irovira.bmp'); imagesc(handles.imagen); axis off; % --- Outputs from this function are returned to the command line. function varargout = am300_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout{1} = handles.output; param=handles.Parametro; descripcion=handles.Descripcion; text=handles.text; descripcion2=handles.Descripcion2; unidades=handles.Unidades; fijar=handles.Fijar; set(param,'visible','off'); set(descripcion,'visible','off'); set(descripcion2,'visible','off'); set(text,'visible','off'); set(unidades,'visible','off'); set(fijar,'visible','off'); handles % --- Executes on selection change in Menu. function Menu_Callback(hObject, eventdata, handles) % hObject handle to Menu (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns Menu contents as cell array % contents{get(hObject,'Value')} returns selected item from Menu %handles clear generadorf; clear moduladas; clear iq;



clear cont; clear parametros; global generadorf; global moduladas; global iq; global cont; global parametros; handles %Inicializamos esta variable porque se intenta cambiar la configuración parametros=''; cont=0; opcion=get(hObject,'value'); %Llamada a la estructura arbol; %opcion %handles param=handles.Parametro; descripcion=handles.Descripcion; text=handles.text; descripcion2=handles.Descripcion2; unidades=handles.Unidades; fijar=handles.Fijar; menu2=handles.menu2; lista=handles.Lista; parametro=handles.Parametro; set(param,'visible','off'); set(descripcion,'visible','off'); set(descripcion2,'visible','off'); set(text,'visible','off'); set(unidades,'visible','off'); set(fijar,'visible','off'); set(menu2,'visible','on'); set(lista,'visible','on'); str={''}; str2={''}; str3={''}; set(menu2,'value',1); set(lista,'value',1); set(menu2,'string',str); set(descripcion,'string',str); set(descripcion2,'string',str); set(lista,'string','');



if opcion==1 defectop; parametros(1).n='Preestablecidas'; parametros(1).v='0'; %Para que nada más iniciar salga la unidad del primer parametro unidad=handles.Unidades; str=generadorf.unidades{1,1}; set(unidad,'string',str); %Se trata de un parche no apreciable, pues si el estado del menu es %3 y insertamos solo 1 opción, hay problemas str=generadorf.opciones; str3= generadorf.descripciont; elseif opcion==2 str=moduladas.opciones; %str3=moduladas.descripcion; elseif opcion==3 set(param,'visible','on'); set(descripcion,'visible','on'); set(descripcion2,'visible','on'); set(text,'visible','on'); set(parametro,'visible','on'); set(unidades,'visible','on'); set(fijar,'visible','on'); defectoiq; %Para que nada más iniciar salga la unidad del primer parametro y su %descipción parametros unidad=handles.Unidades; str=iq.unidades{1,1}; set(unidad,'string',str); str3=iq.descripcion(1); set(descripcion2,'string',str3); %set(menu2,'visible','off'); str={'Fichero IQ'}; str=iq.opciones2; str3=iq.descripciont; str2=iq.opciones; lista=handles.Lista; set(lista,'string',str2); end set(menu2,'string',str); set(descripcion,'string',str3);



% --- Executes during object creation, after setting all properties. function Menu_CreateFcn(hObject, eventdata, handles) % hObject handle to Menu (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in Lista. function Lista_Callback(hObject, eventdata, handles) % hObject handle to Lista (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns Lista contents as cell array % contents{get(hObject,'Value')} returns selected item from Lista global generadorf; global iq; global moduladas; menu=handles.Menu; omenu=get(menu,'value'); unidades=handles.Unidades; opciones=handles.Opciones; descripcion2=handles.Descripcion2; menu2=handles.menu2; set(descripcion2,'visible','on'); if omenu==1 olista=get(hObject,'value'); str=generadorf.unidades{1,olista}; set(unidades,'string',str); str3=generadorf.descripcion(olista); set(descripcion2,'string',str3); elseif omenu==2 olista=get(hObject,'value'); opcion=get(menu2,'value'); opciones=get(menu2,'string'); a=opciones(opcion); str=''; olista=get(hObject,'value');



if 1==strcmp(a,'AM') str=moduladas.am.unidades{1,olista}; set(unidades,'string',str); str3=moduladas.am.descripcion(olista); set(descripcion2,'string',str3); elseif 1==strcmp(a,'FM') str=moduladas.fm.unidades{1,olista}; set(unidades,'string',str); str3=moduladas.fm.descripcion(olista); set(descripcion2,'string',str3); elseif 1==strcmp(a,'FSK') str=moduladas.fsk.unidades{1,olista}; set(unidades,'string',str); str3=moduladas.fsk.descripcion(olista); set(descripcion2,'string',str3); end elseif omenu==3 olista=get(hObject,'value'); str=iq.unidades{1,olista}; set(unidades,'string',str); str3=iq.descripcion(olista); set(descripcion2,'string',str3); end %Ponemos el menu de unidades en la primera posición para que no haya %problemas set(unidades,'value',1); % --- Executes during object creation, after setting all properties. function Lista_CreateFcn(hObject, eventdata, handles) % hObject handle to Lista (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: listbox controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else



set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end set(hObject,'visible','off'); function Parametro_Callback(hObject, eventdata, handles) % hObject handle to Parametro (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % % Hints: get(hObject,'String') returns contents of Parametro as text % str2double(get(hObject,'String')) returns contents of Parametro as a double % % X = str2double('str') converts the string str, which should be an ASCII character representation of a real or complex scalar value, to the MATLAB double-precision representation. The string can contain digits, a comma (thousands separator), a decimal point, a leading + or - sign, an e preceding a power of 10 scale factor, and an i for a complex unit. % % If str does not represent a valid scalar value, str2double returns NaN. % % X = str2double(C) converts the strings in the cell array of strings C to double precision. The matrix X returned will be the same size as C. % --- Executes during object creation, after setting all properties. function Parametro_CreateFcn(hObject, eventdata, handles) % hObject handle to Parametro (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end %set(hObject,'visible','off'); % --- Executes on button press in Aceptar. function Aceptar_Callback(hObject, eventdata, handles) % hObject handle to Aceptar (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)



global parametros; fp=fopen('configuracion.txt','w'); e=exist('parametros'); %Si existe que genere el archivo, en caso contrario mejor no introducir %valores extraños en este if e==1 %fprintf(fp,'%i %12.7f\n', y); % //Para string i=1; while(i<=length(parametros)) a=char(parametros(i).n); fprintf(fp,'%s\t',a); a=char(parametros(i).v); fprintf(fp,'%s\t',a); i=i+1; % end end fclose(fp) menu2=handles.menu2; opcion=get(menu2,'value'); opciones=get(menu2,'string'); a=opciones(opcion); global salida; e=isempty(salida) if 1==strcmp(a,'Proyecto Simulink')&& e==0 b=parametros(3).v; b=str2num(b); a=1:b; salida datos=salida.signals.values; qc=imag(datos(a))*16000; ic=real(datos(a))*16000; A=round([ic,qc]); save canalesiq.txt -ascii A; end end !FS300_Basic_Measurement.exe % --- Executes on button press in Cancelar. function Cancelar_Callback(hObject, eventdata, handles) % hObject handle to Cancelar (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % handles.imagen = imread('cameraman.tif'); % %imagesc(handles.imagen), colormap(gray(256)), axis off, axis([-12,12,-1.5,1.5]) % handles.output; % guidata(hObject,handles); % % axes(handles.imagen);



% handles.imagen=imread('irovira.bmp'); % imagesc(handles.imagen); % axis off; id=gcf delete(id); % --- Executes on selection change in menu2. function menu2_Callback(hObject, eventdata, handles) % hObject handle to menu2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns menu2 contents as cell array % contents{get(hObject,'Value')} returns selected item from menu2 global generadorf; global moduladas; global iq; global parametros; global cont; menu=handles.Menu; menu2=handles.menu2; descripcion2=handles.Descripcion2; parametro=handles.Parametro; descripcion=handles.Descripcion; descripcion2=handles.Descripcion2; param=handles.Parametro; text=handles.text; unidades=handles.Unidades; fijar=handles.Fijar; set(param,'visible','on'); set(descripcion,'visible','on'); set(descripcion2,'visible','on'); set(text,'visible','on'); set(parametro,'visible','on'); set(unidades,'visible','on'); set(fijar,'visible','on'); lista=handles.Lista; opcion=get(hObject,'value'); opciones=get(hObject,'string'); a=opciones(opcion); str=''; %Para que no haya problemas con opciones no validas seleccionadas %anteriormente set(lista,'value',1); %El código posterior servirá para inicializar la unidad del primer %parámatro omenu=get(menu,'value');



if omenu==1 str3=generadorf.descripcion(1); set(descripcion2,'string',str3); a=get(hObject,'value'); a=a-1; if a>4 a=a+3; end str2=generadorf.opciones2; set(lista,'string',str2); strmenu2=get(menu2,'string'); opmenu2=get(menu2,'value'); parametros(2).n=strmenu2(opmenu2); parametros(2).v=char(a+48); elseif omenu==2 %En este caso se supone que cambiamos totalmente la configuración, por %tanto debemos reconfigurar el vector parametros (debemos poner global para que se borre de manera global) clear global parametros; if 1==strcmp(a,'AM') defectoam; str=moduladas.am.opciones; set(lista,'string',str); str2=moduladas.am.descripciont; str3=moduladas.am.descripcion(1); str4=moduladas.am.unidades{1,1}; elseif 1==strcmp(a,'FM') defectofm; str=moduladas.fm.opciones; set(lista,'string',str); str2=moduladas.fm.descripciont; str3=moduladas.fm.descripcion(1); str4=moduladas.fm.unidades{1,1}; elseif 1==strcmp(a,'FSK') defectofsk; str=moduladas.fsk.opciones; set(lista,'string',str); str2=moduladas.fsk.descripciont; str3=moduladas.fsk.descripcion(1); str4=moduladas.fsk.unidades{1,1}; end set(descripcion,'string',str2); set(descripcion2,'string',str3); set(unidades,'string',str4);



elseif omenu==3 if 1==strcmp(a,'Archivo I/Q') [filename, pathname] = uigetfile( ... {'*.m;*.fig;*.mat;*.mdl', 'All MATLAB Files (*.m, *.fig, *.mat, *.mdl)'; ... '*.*', 'All Files (*.*)'}, ... 'Pick a file'); if filename~=0 direccion=strcat(pathname,filename); direccion=strcat('"',direccion,'"'); direccion comandados=dos(['copy ',direccion,' ','canalesiq.txt']); end elseif 1==strcmp(a,'Proyecto Simulink') [filename, pathname] = uigetfile( ... {'*.m;*.fig;*.mat;*.mdl', 'All MATLAB Files (*.mdl)'; ... '*.*', 'All Files (*.*)'}, ... 'Pick a file'); if filename~=0 direccion=strcat(pathname,filename); open(direccion); end end end function menu2_CreateFcn(hObject, eventdata, handles) % hObject handle to menu2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end set(hObject,'visible','off');



% --- Executes on selection change in Unidades. function Unidades_Callback(hObject, eventdata, handles) % hObject handle to Unidades (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns Unidades contents as cell array % contents{get(hObject,'Value')} returns selected item from Unidades % --- Executes during object creation, after setting all properties. function Unidades_CreateFcn(hObject, eventdata, handles) % hObject handle to Unidades (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end % --- Executes on button press in Fijar. function Fijar_Callback(hObject, eventdata, handles) % hObject handle to Fijar (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global generadorf; global moduladas; global iq; global parametros; global cont; parametro=handles.Parametro; amplitud = str2double(get(parametro,'string')); if isnan(amplitud) errordlg('Introduce un valor numérico','Entrada incorrecta','modal') else menu=handles.Menu; menu2=handles.menu2; lista=handles.Lista; parametro=handles.Parametro; descripcion=handles.Descripcion2; param=handles.Parametro; text=handles.text;



unidades=handles.Unidades; omenu=get(menu,'value'); omenu2=get(menu2,'value'); esc=get(unidades,'value'); if omenu==1 %Establecemos el parametro1 antes de fijar nada %Fijamos el valor de la variable seleccionada por menu2 strlista=get(lista,'string'); olista=get(lista,'value'); parametros(olista+2).n=strlista(olista); v=get(parametro,'string'); fscala=generadorf.escala{1,olista}{1,esc}; v=str2num(v); v=fscala*v; v=num2str(v); parametros(olista+2).v=v; elseif omenu==2 opcion=get(menu2,'value'); opciones=get(menu2,'string'); a=opciones(opcion); olista=get(lista,'value'); if 1==strcmp(a,'AM') fscala=moduladas.am.escala{1,olista}{1,esc}; elseif 1==strcmp(a,'FM') fscala=moduladas.fm.escala{1,olista}{1,esc}; elseif 1==strcmp(a,'FSK') opcion esc fscala=moduladas.fsk.escala{1,olista}{1,esc}; end strlista=get(lista,'string'); olista=get(lista,'value'); parametros(olista+2).n=strlista(olista); v=get(parametro,'string'); v=str2num(v); v=fscala*v; v=num2str(v); parametros(olista+2).v=v; elseif omenu==3 opcion=get(lista,'value'); opciones=get(lista,'string'); a=opciones(opcion);



strlista=get(lista,'string'); olista=get(lista,'value'); parametros(olista+1).n=strlista(olista); v=get(parametro,'string'); fscala=iq.escala{1,olista}{1,esc}; v=str2num(v); v=fscala*v; v=num2str(v); parametros(olista+1).v=v; v=str2num(v); if and(1==strcmp(a,'Voltaje'), v>5) parametros(olista+1).v=num2str(5); end end end 2.3. Adquisición de datos del FSP a través de GPIB

El FSP es un analizador de espectros que permite a través de GPIB (entre otras posibilidades) adquirir datos, en nuestro caso particular nos interesará adquirir los datos I/Q de lo que tiene en su canal. El esquema siguiente muestra en un diagrama de bloques que utiliza este analizador, los diferentes elementos son configurables como se puede observar:

Figura 51. Diagrama de bloques, que ilustra el procesamiento de la señal



Utilizaremos el GPIB para enviar la configuración al analizador, a continuación introduciremos el código, en este no entraremos en detalle en las funciones enviar y recibir, solo mostraremos el tipo de nomenclatura utilizada:

address=20; enviar(address,'TRAC:IQ:STAT ON');

enviar(address,'TRAC:IQ:SET NORM,1MHz,125kHz,IMM,POS,0,1024'); enviar(address,'FORM:DATA REAL,32'); enviar(address,'TRAC:IQ:DATA?'); y=rebrefsp(20); npoints=length(y)/2; IChannel=y(1:npoints/2); QChannel=y((npoints/2+1):npoints); plot(IChannel,QChannel,'.')

En la tercera instrucción es donde principalmente se realiza la configuración, el primer parámetro seria el ancho de banda del filtro, el segundo es el “sample rate” que es fijo, utilizamos el “trigger” interno y con el modo “slope” activado (POS), el “pretrigger” a 0 y por último el número de muestras de 1024.

Posteriormente lo que hacemos es recibir la información del propio periférico, el

formato es el siguiente: #41024<I-value1><I-value2>...<I-value128><Q-value1><Q-value2>...<Q-value128>

Finalmente con la función rebrefsp devuelve un array de valores de los canales I/Q, de lo cuales la primera mitad son los I y el resto los Q, con estos datos dibujaremos la constelación I/Q.



2.4. Fichero de configuración

Como hemos mencionado en apartados anteriores, la interfaz de Matlab nos genera un fichero de configuración, que capta el programa en C y el cual manda las ordenes al periférico. En las figuras posteriores se muestra los diferentes formatos que puede tener dicho archivo:

Figura 51. Formato para señales preestablecidas En cuanto a modulaciones normales AM, FM y FSK, los formatos de configuración serán los siguientes:

Figura 52. Formato para modulaciones Por otro lado tenemos que para la modulación basada en I/Q utilizaremos el siguiente formato:

. . Figura 53. Formato para modulación I/Q



2.5. Fichero I/Q Este contiene los datos I/Q de una señal arbitraria, el formato que le hemos dado es simple, cada columna representará un canal:

Figura 54. Formato archivo canales I/Q

2.6. Ficheros de inicialización

La interfaz gráfica en principio no podría funcionar por si sola, por esta razón creamos una serie de archivos de configuración, el más importante y el que genera toda la base de variables es el arbol.m. El funcionamiento es simple, se ejecuta arbol.m y de esta forma se crean todas las variables que nos interesan, posteriormente, según la elección del usuario, utilizaremos el resto de archivos para ir cargando datos en el vector parámetros, todo esto se intuye en la figura posterior, y se acabará de entender con el propio código de la aplicación.



Figura 55. Archivos de configuración de la I.gráfica

• Arbol.m:

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% global generadorf; generadorf.opciones={'Sinusoide','Cuadrada','Triangular','Rampa','Ruido','Exponencial','Exponencial inv','Pulso'}; generadorf.opciones2={'Amplitud','Frecuencia','Offset'}; generadorf.unidades={{'mV','V','kV'},{'Hz','kHz','MHz'},{'mV','V','kV'}};



generadorf.escala={{0.001,1,1000},{1,1000,1000000},{0.001,1,1000}}; generadorf.name='opcion 0'; generadorf.tipo.v='0'; generadorf.amplitud.v='5'; generadorf.frecuencia.v='1000'; generadorf.offset.v='0'; generadorf.descripciont={'Se genera una señal preestablecida con unos determinados parámetros'}; generadorf.descripcion(1)={'Fijamos la amplitud de la señal, el valor por defecto es de 5 V'}; generadorf.descripcion(2)={'Fijamos la frecuencia, el valor por defecto es de 1000 Hz'}; generadorf.descripcion(3)={'Fijamos la offset, el valor por defecto es de 0 V'}; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% global moduladas; moduladas.opciones={'AM', 'FM', 'FSK'}; moduladas.am.opciones={'Indice','Funcion','Frecuencia'}; moduladas.am.unidades={{'%'},{'Señal'},{'Hz','kHz','MHz'}}; moduladas.am.escala={{1},{1},{1,1000,1000000}}; moduladas.am.indice.v='50'; moduladas.am.modulada.v='0'; moduladas.am.frecuencia.v='1000'; moduladas.am.descripciont={'Generamos una modulación en amplitud AM'}; moduladas.am.descripcion(1)={'Se establece el coeficiente de modulación de una señal AM, este se introducirá mediante un porcentaje'}; moduladas.am.descripcion(2)={'Se trata de modular una de los siguientes tipo de señales: 0-->Sinusoide, 1-->Cuadrada, 2-->Triangular, 3-->Rampa arriba, 4-->Rampa abajo, 8-->Exponencial inv, 9-->Exponencial'}; moduladas.am.descripcion(3)={'Introducimos la frecuéncia de la modulación, el valor por defecto: 10.0e3 Hz'}; moduladas.fm.opciones={'Desviacion','Modulada','Frecuencia'}; moduladas.fm.unidades={{'Hz','kHz','MHz'},{'Señal'},{'Hz','kHz','MHz'}}; moduladas.fm.escala={{1,1000,1000000},{1},{1,1000,1000000}}; moduladas.fm.desviacion.v='1000'; moduladas.fm.modulada.v='0'; moduladas.fm.frecuencia.v='1000'; moduladas.fm.descripciont={'Generamos una modulación en frecuéncia FM'}; moduladas.fm.descripcion(1)={'Desviación en la modulación FM, el valor por defecto: 10.0e3 Hz'}; moduladas.fm.descripcion(2)={'Se trata de modular el siguiente tipo de señales: 0-->Sinusoide, 1-->Cuadrada, 2-->Triangular, 3-->Rampa arriba, 4-->Rampa abajo, 8-->Exponencial inv, 9-->Exponencial'}; moduladas.fm.descripcion(3)={'Se establece la frecuencia de la señal, el valor por defecto: 10.0e3 Hz'}; moduladas.fsk.opciones={'SaltoF','Frecuencia2'}; moduladas.fsk.unidades={{'Hz','kHz','MHz'},{'Hz','kHz','MHz'}};



moduladas.fsk.escala={{1,1000,1000000},{1,1000,1000000}}; moduladas.fsk.frecuencia.v='1000'; moduladas.fsk.frecuencia2.v='1000'; moduladas.fsk.descripciont={'Generamos una modulación FSK'}; moduladas.fsk.descripcion(1)={'Fijamos el salto de frecuencia de la modulación FSK, el valor por defecto: 10.0e3 Hz'}; moduladas.fsk.descripcion(2)={'Fijamos la variación de frecuéncia en la salida entre la portadora y el salto de frecuéncia, el valor por defecto: 10e3 Hz'}; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% global iq; iq.opciones={'Frecuencia', 'nPuntos','Voltaje'}; iq.opciones2={'Proyecto Simulink', 'Archivo I/Q'}; iq.unidades={{'Hz','kHz','MHz'},{'Puntos'},{'mV','V','kV'}}; iq.escala={{1,1000,1000000},{1},{0.001,1,1000}}; iq.muestreo='1000'; iq.puntos='1024'; iq.voltaje='0.5'; iq.descripciont={'Se extrae del fichero los datos necesarios para generar los dos canales I/Q, que posteriormente genera el AM300.'}; iq.descripcion(1)={'Fijamos la frecuencia, el valor por defecto: 1000 Hz'}; iq.descripcion(2)={'Fijamos el número de puntos. Tener en cuenta que si no hay los suficientes puntos en el archivo, los vectores se inicializan con 0. La dimension por defecto: 1024 puntos'}; iq.descripcion(3)={'Fijamos la escala de voltaje, el valor por defecto: 0.5 V'}; Por otro lado tenemos que en según que eventos se produzcan en la interfaz gráfica, se deberán inicializar los valores por defecto, así pues utilizaremos el vector parámetros para esto. Cada configuración requerirá un fichero de inicialización diferente, a continuación iremos describiendo de forma genérica en que casos se utiliza cada uno:

• Defectop.m:. function defectop() global parametros; global generadorf; parametros(2).n='Sinusoide'; parametros(2).v=char(generadorf.tipo.v); parametros(3).n='Amplitud'; parametros(3).v=generadorf.amplitud.v; parametros(4).n='Frecuencia'; parametros(4).v=generadorf.frecuencia.v; parametros(5).n='Offset'; parametros(5).v=generadorf.offset.v;



• Defectoam.m: como su propio nombre indica se trata de la inicialización de

valores por defecto de una modulación AM.

function defectoam() global parametros; global moduladas; parametros(1).n='Moduladas'; parametros(1).v='1'; parametros(2).n='Opcion'; parametros(2).v='0'; parametros(3).n='Indice'; parametros(3).v=moduladas.am.indice.v; parametros(4).n='Función'; parametros(4).v=moduladas.am.modulada.v; parametros(5).n='Frecuencia'; parametros(5).v=moduladas.am.frecuencia.v;

• defectofm.m: en este caso será la inicialización para una señal fm.

function defectofm() global parametros; global moduladas; parametros(1).n='Moduladas'; parametros(1).v='1'; parametros(2).n='Opcion'; parametros(2).v='1'; parametros(3).n='Desviación'; parametros(3).v=moduladas.fm.desviacion.v; parametros(4).n='Función'; parametros(4).v=moduladas.fm.modulada.v; parametros(5).n='Frecuencia'; parametros(5).v=moduladas.fm.frecuencia.v;

• defectofsk.m: inicialización para una señal fsk.

function defectofsk() global parametros; global moduladas; parametros(1).n='Moduladas'; parametros(1).v='1'; parametros(2).n='Opcion'; parametros(2).v='2'; parametros(3).n='SaltoF'; parametros(3).v=moduladas.fsk.frecuencia.v; parametros(4).n='Frecuencia'; parametros(4).v=moduladas.fsk.frecuencia2.v;



• defectoiq.m: inicialización para modulación I/Q.

function defectoiq() global parametros; global generadorf; global iq; parametros(1).n='IQ'; parametros(1).v='2'; parametros(2).n='Frecuencia'; parametros(2).v=iq.muestreo; parametros(3).n='nPuntos'; parametros(3).v=iq.puntos; parametros(3).n='Voltaje'; parametros(3).v=iq.voltaje;


3. Anexos

3. ANEXOS


3. Anexos

3.1. Anexo I: Bibliografía La bibliografía consultada a lo largo de la elaboración del presente proyecto se enumera detalladamente a continuación:

• Referencias a paginas Web: [1] http://www.rohde-schwarz.com/, [Modulador I/Q AM300 Rhode&Schwarz (drivers, tutoriales, manuales y otros documentos)] . [2] , http://www.educatorscorner.com/index.cgi?CONTENT_ID=2478, [Información sobre modulación IQ]. [5] http://www.gimilio.com/gimilio/esp/descargas/tercero.php, [Modulaciones digitales]. [6] http://www.lawebdelprogramador.com, [Foro Matlab, de la Web del programador]. [7] http://www.universas.com/matlab, [El rincón de Matlab]. [8] http://foros.solocodigo.com/ , [Foros de solo codigo].

• Libros: [9] Electrónica de comunicaciones, Manuel Sierra Pérez et al,Prentice Hall. [10] Radio Receiver Design, R.C. Dixon,Marcel Dekker, Inc. [12] Fundamentals of RF Circuit Design with Low Noise Oscillators, J.Everart, Wiley & Sons,2001. [13] Modern Receiver Front End, J.Laskar, Wiley & Sons,2004 [14] Practical RF Circuit Design for modern wireless systems, R.Gilmore, L..Besser,Atech House, 2003. [15] Microwave and Wireless Synthesizers: Theory and Design, Ulrich Rohde, John Wiley & Sons Inc, 1997.


http://www.educatorscorner.com/index.cgi?CONTENT_ID=2478

http://www.gimilio.com/gimilio/esp/descargas/tercero.php

http://www.lawebdelprogramador.com/

http://www.universas.com/matlab

3. Anexos

3.2. Anexo II: Funciones de la librería Código en C++

En este anexo describiré las principales funciones para el control del AM300, esta claro que únicamente se mencionarán algunas de las más importantes, puesto que el resto se encuentran en la ayuda del controlador. 3.2.1. Inicialización Primeramente deberemos inicializar el instrumento, para ello la instrucción siguiente:

ViStatus rssiam_init (ViRsrc resourceName, ViBoolean idQuery, iBoolean resetDevice, ViSession* instrumentHandle);

Podemos observar que devuelve un Status, el cual tendrá diferentes valores según como se haya realizado la función, este Status se usa para todas las funciones, de esta manera detallaremos los valores posibles y que significan:

Returns the status code of this operation. The status code either indicates success or describes an error or warning condition. You examine the status code from each call to an instrument driver function to determine if an error occurred. To obtain a text description of the status code, call the rssiam_error_message function. The general meaning of the status code is as follows: Value Meaning ------------------------------- 0 Success Positive Values Warnings Negative Values Errors This instrument driver also returns errors and warnings defined by other sources. The following table defines the ranges of additional status codes that this driver can return. The table lists the different include files that contain the defined constants for the particular status codes: Numeric Range (in Hex) Status Code Types ------------------------------------------------- 3FFF0000 to 3FFFFFFF VISA Warnings 3FFC0000 to 3FFCFFFF VXIPnP Driver Warnings BFFF0000 to BFFFFFFF VISA Errors BFFC0000 to BFFCFFFF VXIPnP Driver Errors

• Los propósitos de esta función son los siguientes:

This function performs the following initialization actions: - Opens a session to the specified device using the interface and address specified in the Resource_Name control.


3. Anexos

- Performs an identification query on the Instrument. - Resets the instrument to a known state. - Sends initialization commands to the instrument. - Returns an Instrument Handle which is used to differentiate between different sessions of this instrument driver. - Each time this function is invoked a Unique Session is opened. It is possible to have more than one session open for the same resource.

• Los parámetros de entrada de esta función son los siguientes:

Name Type Description resourceName ViRsrc This control specifies the interface and address

of the device that is to be initialized (Instrument Descriptor). The exact grammar to be used in this control is shown in the note below. Default Value: "USB::0xAAD::0x5::100011" Notes: (1) Based on the Instrument Descriptor, this operation establishes a communication session with a device. The grammar for the Instrument Descriptor is shown below. Optional parameters are shown in square brackets ([]). Interface Grammar ------------------------------------------------------ USB::manufacturer_ID::model_code::serial_number The USB keyword is used for USB interface. Serial number is a instrument's box (Model) Serial Number. The driver also supports logical names. You can pass logical name instead of instrument descriptor. Example: "device_1" instead of "USB::0x0aad::0x5::123456". Logical names can be configured with the SiScan application.

idQuery ViBoolean This control specifies if an ID Query is sent to the instrument during the initialization procedure. Valid Range: VI_FALSE (0) - Skip Query VI_TRUE (1) - Do Query (Default Value) Notes:


3. Anexos

(1) Under normal circumstances the ID Query ensures that the instrument initialized is the type supported by this driver. However circumstances may arise where it is undesirable to send an ID Query to the instrument. In those cases; set this control to "Skip Query" and this function will initialize the selected interface, without doing an ID Query.

resetDevice ViBoolean This control specifies if the instrument is to be reset to its power-on settings during the initialization procedure. Valid Range: VI_FALSE (0) - Don't Reset VI_TRUE (1) - Reset Device (Default Value) Notes: (1) If you do not want the instrument reset. Set this control to "Don't Reset" while initializing the instrument.

instrumentHandle ViSession This control returns an Instrument Handle that is used in all subsequent function calls to differentiate between different sessions of this instrument driver. Notes: (1) Each time this function is invoked a Unique Session is opened. It is possible to have more than one session open for the same resource.

3.2.2. Configuración de canales 3.2.2.1. Configuración de la salida

Esta función permite activar uno de los dos canales, las configuraciones posteriores afectaran a este canal activo. ViStatus rssiam_outpChannel (ViSession instrumentHandle, ViInt16 activeChannel);


This function selects active channel for which are the settings applied. Note: Channel based operations are noted in the descriptions (applicable channels are listed).


3. Anexos

• Los parámetros de esta función son los siguientes:

Name Type Description instrumentHandle ViSession This control accepts the Instrument Handle returned by the

Initialize function to select the desired instrument driver session. Default Value: None

activeChannel ViInt16 Selects active channel. Valid Values: RSSIAM_CH1 (1) - CH1 (Channel 1) RSSIAM_CH2 (2) - CH2 (Channel 2) Default Value: 1

3.2.2.2. Configuración de acoplamiento de los canales

Esta función permite configurar los canales, acoplándolos:

ViStatus rssiam_outpChannelCoupl (ViSession instrumentHandle, ViInt16 channelCoupling);


Select output channel(s) coupling.


Name Type Description

instrumentHandle ViSession This control accepts the Instrument Handle returned by the Initialize function to select the desired instrument driver session. Default Value: None

channelCoupling ViInt16 Select output channel(s) coupling. Valid Values: RSSIAM_CHANNEL_COUPLING_OFF (0x0) - Coupling OffRSSIAM_CHANNEL_COUPLING_FREQ (0x1) - Frequency RSSIAM_CHANNEL_COUPLING_AMPT (0x2) - Amplitude RSSIAM_CHANNEL_COUPLING_OUTPUT (0x4) - Output RSSIAM_CHANNEL_COUPLING_PHASE (0x8) - Phase


3. Anexos

Default Value: 0x1 Notes: (1) Bit mask is used to set channel coupling. (2) Carrier frequency is common for both of channels if any of the coupling functions is activated. (3) If coupling is set to Off, instrument acts with two independent carrier frequencies. Example: To set frequency, amplitude and phase channel coupling pass following RSSIAM_CHANNEL_COUPLING_FREQ || RSSIAM_CHANNEL_COUPLING_AMPT || RSSIAM_CHANNEL_COUPLING_PHASE which is equal to (0x1) || (0x2) || (0x8) = 0xB

3.2.3. Configuración de parámetros 3.2.3.1. Frecuencia En este caso conseguimos establecer la frecuencia, de los canales. ViStatus rssiam_freq (ViSession instrumentHandle, ViReal64 frequency);


Sets the carrier frequency of the output signal (Hz). Applicable channels: CH1, CH2 if device config selects two independent frequencies Note: If device config selects common frequency (see function Output Channel Coupling (rssiam_outpChannelCoupl())), channel does not apply.



instrumentHandle ViSession This control accepts the Instrument Handle returned by the Initialize function to select


3. Anexos

the desired instrument driver session. Default Value: None

frequency ViReal64 Carrier frequency of the output signal. Valid Range: 10.0e-6 Hz to 50.0e6 Hz Default Value: 1000.0 Hz Note: Carrier frequency range depends on the function currently selected.

3.2.3.2. Amplitud Permite configurar la amplitud de una señal cualquiera. ViStatus rssiam_volt (ViSession instrumentHandle, ViReal64 voltage);


Sets the output amplitude for currently active function. Applicable channels: CH1 or CH2




voltage ViReal64 Sets the output amplitude. Valid Ranges: Peak-to-peak: 0.001 V to 10 V DC function only: -5.0 V to 5.0 V Default Value: 1.0 V Note: The relationship between Voltage Amplitude (Vpp) and Voltage Offset (Voffset) is Vmin <= (Voffset + Vpp/2) <= Vmax


3. Anexos

where Vmax is set by function Output Voltage High Setup (rssiam_voltHigh) and Vmin is set by function Output Voltage Low Setup (rssiam_voltLow).

3.2.3.3. Offset Fijamos el offset de una señal estándar. Function rssiam_voltOffs (ByVal instrumentHandle As ViSession, ByVal voltageOffset As ViReal64) As ViStatus


Sets the DC offset voltage for currently active function. Applicable channels: CH1 or CH2


Name Type Description instrumentHandle ViSession This control accepts the Instrument Handle

returned by the Initialize function to select the desired instrument driver session. Default Value: None

voltageOffset ViReal64 Sets the DC offset voltage. Valid Range: -5.0 V to 5.0 V Default Value: 0.0 V Note: The relationship between Voltage Amplitude (Vpp) and Voltage Offset (Voffset) is Vmin <= (Voffset + Vpp/2) <= Vmax where Vmax is set by function Output Voltage High Setup (rssiam_voltHigh) and Vmin is set by function Output Voltage Low Setup (rssiam_voltLow).


3. Anexos

3.2.4. Activar salida Activa la salida, de esta forma se generará las señales previamente configuradas. ViStatus rssiam_outpSetup (ViSession instrumentHandle, ViInt16 outputSetup);


Enables or disables the front-panel output connector. Applicable channels: CH1 or CH2




outputSetup ViInt16 Enables or disables the front-panel output connector. Valid Values: RSSIAM_OUTPUT_SETUP_OFF (0) - Off RSSIAM_OUTPUT_SETUP_ON (1) - On Default Value: 0

3.2.5. Señales arbitrarias 3.2.5.1. Puntos Función que carga los puntos dentro de la memoria volátil del periférico.

ViStatus rssiam_dataArbPoin (ViSession instrumentHandle, ViInt32 dataPoints);


Sets the number of points to be used from the arbitrary waveform memory when Data Arb Rate Mode is set to Sample Accurate (fixed settings). Note: Output Function Shape should be set to User.


3. Anexos




dataPoints ViInt32 Sets the number of points to be used from the arbitrary waveform memory. Valid Range: 16 to 262144 Default Value: 16

3.2.5.2. Inicio de lectura Establecemos donde empezamos la lectura del vector. ViStatus rssiam_dataArbStart (ViSession instrumentHandle, ViInt32 dataStart);


Sets the start point in waveform memory when Data Arb Rate Mode is set to Sample Accurate (fixed settings). Applicable channels: CH1 or CH2 Note: Output Function Shape should be set to User.




dataStart ViInt32 Sets the start point in waveform memory. Valid Range: 0 to 262143 Default Value: 0


3. Anexos

3.2.5.3. Finalización de la lectura Establecemos la finalización de lectura de los vectores.

ViStatus rssiam_dataArbStop (ViSession instrumentHandle, ViInt32 dataStop);


Sets the stop point in waveform memory when Data Arb Rate Mode is set to Sample Accurate (fixed settings). Applicable channels: CH1 or CH2 Note: Output Function Shape should be set to User.




dataStop ViInt32 Sets the stop point in waveform memory. Valid Range: 0 to 262143 Default Value: 262143

3.2.5.4. “Sample rate” Configuramos la velocidad con la que se extraen los puntos al canal.

ViStatus rssiam_dataArbRate (ViSession instrumentHandle, ViReal64 dataSampleRate);



3. Anexos

Sets the sample rate for the arbitrary waveform when Data Arb Rate Mode is set to Sample Accurate (fixed settings). Note: Output Function Shape should be set to User




dataSampleRate ViReal64 Sets the sample rate for the arbitrary waveform. Valid Range: 1.0e-5 Hz to 100.0e6 Hz Default Value: 100.0e6 Hz

3.2.5.5. “Rate mode” Establecemos el modo de sintetizado que sea normal o sample accurate.

ViStatus rssiam_dataArbRateMode (ViSession instrumentHandle, ViInt16 dataSampleRateMode);


Sets the arbitrary waveform sample rate mode to Normal or customized Sample Accurate setting. Note: Output Function Shape should be set to User.





3. Anexos

dataSampleRateMode ViInt16 Sets the arbitrary waveform sample rate mode to Normal or customized Sample Accurate setting. Valid Values: RSSIAM_ARB_RATE_MODE_NORMAL (0) - Normal RSSIAM_ARB_RATE_MODE_ACCURATE (1) - Sample Accurate Default Value: 0

3.2.5.6. Carga de vectores en la memoria volátil I Cargamos los vectores dentro de la memoria volátil, hay que indicarle el número de puntos. Se utilizan floats en este caso. ViStatus rssiam_dataVolatile (ViSession instrumentHandle, ViInt32 noofPoints, ViReal64[] dataArray);


Uploads floating-point values between -1 and +1 into volatile memory. Out of ramge values are coerced to the lower (upper) range limit. The values -1 and +1 correspond to the peak values of the waveform. Downloading the floating-point values is slower than downloading binary values but is more convenient when using the trigonometric functions, which return values between -1 and +1. This function overwrites the previous waveform in VOLATILE memory. Applicable channels: CH1 or CH2 Note: Output Function Shape should be set to User.




noofPoints ViInt32 Number of floating-point values to be uploaded. Valid Range: 16, 32, ... 262144 (in steps of


3. Anexos

power of two) Default Value: 16

dataArray ViReal64[] Floating-point values between -1 and +1 to upload into volatile memory.

3.2.5.7. Carga de vectores en la memoria volátil II

Se cargan los vectores igual que en el caso anterior, pero ahora se utilizarán integers,

que son más eficientes. ViStatus rssiam_dataDacVolatile (ViSession instrumentHandle, ViInt32 noofPoints, ViInt16[] dataArray);


Uploads binary integer values between -16383 and 16383 into volatile memory. The binary range of values corresponds to the values available using internal 14-bit DAC codes. The values -16383 and 16383 correspond to the peak values of the waveform. MSB (Most Significant Bit at position 15) represents marker state, where On (1) and Off (0). This function overwrites the previous waveform in VOLATILE memory. Applicable channels: CH1 or CH2 Note: Output Function Shape should be set to User.




noofPoints ViInt32 Number of binary integer values to upload into volatile memory. Valid Range: 16, 32, ... 262144 (in steps of power of two) Default Value: 16

dataArray ViInt16[] Binary integer values between -16383 and 16383 to upload into volatile memory.


3. Anexos

3.2.6. Cierre de conexión Con esta función indicamos la finalización, del uso del instrumento cerrando la conexión. ViStatus rssiam_close (ViSession instrumentHandle);


This function closes session to the instrument. Notes: (1) The instrument must be reinitialized to use it again.




3.2.7. Errores Se utiliza para detectar errores e incompatibilidades en las configuraciones, funciona de la forma siguiente, se le referencia el Status y a partir de su código se interpreta y devuelve un string legible para el usuario. ViStatus rssiam_error_message (ViSession instrumentHandle, ViStatus statusCode, ViChar[] message);


This function takes the Status Code returned by the instrument driver functions, interprets it and returns it as a user readable string.





3. Anexos

statusCode ViStatus This control accepts the Status Code returned from the instrument driver functions. Default Value: 0 - VI_SUCCESS

message ViChar[] This control returns the interpreted Status Code as a user readable message string. Notes: (1) The array must contain at least 256 elements ViChar[256].


3. Anexos

3.3. Anexo III: Guide de Matlab

En este apartado comentaré los diferentes elementos a tener en cuenta para poder empezar a programar la interfaz de Matlab mediante la herramienta Guide. 3.3.1. Introducción

Utilizaremos la herramienta GUIDE (Graphical User Interface Development Enviroment) para realizar la interfaz gráfica, así pues GUIDE es una serie de herramientas que proporciona Matlab para la creación de GUIs (Graphical User Interface). Los GUI son uno o varios paneles que contienen los siguientes elementos:

• Controles (botones, menús desplegables, etc.), que permitirán al usuario interactuar con el GUI y establecer el flujo de ejecución.

• Menús. • Eje de coordenadas (axes), que permiten dibujar gráficos e imágenes.

Lo que haremos es utilizar el GUIDE para:

• Diseñar el aspecto del GUI. • Programar el GUI: este genera de forma automática un fichero.m, que

controla el funcionamiento del GUI. Como hemos comentado antes este fichero.m inicializa el GUI y además contiene todos los callbacks (evento) del GUI, dentro de estos podremos añadir código que queramos que se ejecute, cuando suceda algún evento.

Las ventajas que proporciona el uso del GUIDE es evidente, ya que permite

programar código Matlab sin necesidad de comprender mucho la sintaxis del los eventos, y nos evitamos trabajar desde la ventana de ordenes (Command Window) con lo que esto comporta.

Hay que diferenciar el uso de GUIs con el uso de scripts o funciones, se trata de que el primero no predetermina el flujo del código, pues hay que tener en cuenta que el usuario interviene interaccionando con esta, por tanto este decide como avanza la aplicación (no se sabe cuando se finaliza).

El desarrollo del GUI ya se va intuyendo, primeramente realizaremos el diseño de los componentes (controles, menús etc) y posteriormente el código de respuesta a los diferentes eventos que realice el usuario.


3. Anexos

3.3.2. Herramienta En la siguiente figura se podrá observar la herramienta y sus diferentes elementos:

Componentes de la paleta

Editor de menusAlineación

Editor de orden Fichero.m

Editor de menus Propiedades

Arrancar

Figura 56. Herramienta GUIDE A continuación describiremos de forma general, todos los componentes de esta herramienta:

• Barra de menús: donde encontramos las diferentes funciones de edición de GUIs. • Paleta de componentes: esta contiene todos los componentes que podemos añadir a

nuestro GUI. o “Push Button”: genera una acción cuando se le pulsa. o “Toggle Button”: genera un evento y se puede saber si se ha activado o no. o “Check Box”: también genera una acción e indica si está activado. Permiten

establecer un conjunto de elecciones independientes. o “Radio Button”: Iguales que los anteriores pero si se agrupan pueden ser

excluyentes. o “Edit text”: entrada de cadenas de caracteres por parte de el usuario. o “Static Text”: Se utiliza para introducir etiquetas, la diferencia respecto al

anterior es que no pude ser modificable por parte del usuario. o “Slider”: barra deslizable con la que el usuario puede introducir un valor de

un rango.


3. Anexos

o “List Box”: se muestra una lista de opciones seleccionables por parte del usuario.

o “Pop-Up Menu”: simplemente se muestra una lista de opciones. o “Axes”: permite mostrar gráficos e imágenes. o “Panel”: permite agrupar componentes del GUI, para mejorar su

comprensión (elementos hijos). o “Button Group”:similar al panel pero exclusivos para insertar botones radio

y Toogle. o “Activex Component”: permite mostrar controles ActiveX en el GUI.

• Barra de herramientas:

o “Herramientas de alineación”(Alignment Tool) :establecer opciones de

alineación entre los diferentes componentes del GUI. o “Editor de menús”(Menu Editor): nos permite definir entradas que

compondrán el GUI. o “Editor de orden de tabulación”(Tab Order Editor) : establecer el orden que

se accede a los componentes. o “Editor de ficheros .m” (M-file Editor): acceder al código mediante el

fichero .m . o “Inspector de propiedades” (Property Inspector): permite examinar y

cambiar propiedades de los componentes. o “Navegador de objetos” (Object Browser) : permite entre otras cosas

organizar los objetos según su jerarquía. o “Botón de ejecución” (Run Button) : ejecutar la interfaz.

3.3.3. Organización de objetos Matlab permite como sabemos una serie de funciones de dibujo y de visualización de datos, ahora veremos los tres niveles diferentes con los que se puede trabajar:

• Trabajando con objetos del tipo figure, estos sitúan un eje de coordenadas, los cuales ayudan a visualizar los datos.

• El denominado “bajo nivel” realizando las llamadas a la función set y similares, para establecer las propiedades a los objetos, que se hayan creado o para modificarlas a medida que se ejecuta el programa. Esta es la opción de programación convencional y es la que utilizamos como se puede observar en el código de la aplicación.

• Utilizando GUIDE, para desarrollar GUIs, que permiten de forma sencilla definir componentes gráficos y configurar sus eventos. La principal ventaja es que en todo momento podemos elegir si queremos trabajar a alto o bajo nivel.

En cualquiera de estas opciones, se utiliza el sistema de gráficos de Matlab, como en todos los lenguajes de programación, los objetos gráficos tienen unas jerarquías:


3. Anexos

Figura 57. Jerarquía de objetos

Comentar que cada objeto está asociado a un identificador (handle) único des de el momento de su creación, a través de este podremos acceder y modificar las características de un objeto gráfico. Respecto a estos identificadores resaltar que el de la pantalla es cero y los de las diferentes ventanas (figure) son enteros y por otra parte los identificadores de los demás objetos gráficos son reales.

Todo esto se puede complicar debido a que puede haber más de una ventana abierta, pero solamente una permanece activa (última ventana seleccionada). Se pueden obtener los identificadores de las ventanas, ejes y objetos activos con las ordenes siguientes:

• gcf: devuelve un entero, el ID de la ventana activa. • gca: devuelve un ID de los identificadores de los ejes activos. • gco: devuelve el ID del identificador del objeto activo.

La utilidad de los identificadores es la de poder acceder a los objetos gráficos, pudiendo modificar las propiedades de estos o incluso eliminarlos:

• set(id) : muestra por pantalla las propiedades del objeto a partir del id. • get(id): genera un listado de las propiedades y de sus valores • set(id, ‘propiedad’,’valor’): se establece un nuevo valor para la propiedad

del objeto. • get(id, ‘propiedad’): obtiene el valor de la propiedad específica. • delete(id): borra un objeto a partir de su id.

Todo lo anterior ha sido muy utilizado para realizar la interfaz, pues permite

dinamismo a eventos realizados por el usuario. Todos los objetos se insertan en una estructura llamada handles que se genera en ejecutar la interfaz, de esta manera iremos accediendo a identificadores de los objetos, y podremos modificar sus propiedades.


3. Anexos

3.3.4. Almacenamiento de GUIs

Una vez hemos realizado el diseño (no entraremos a explicar profundamente) del GUI utilizando GUIDE, se ha de saber que este se almacena de la forma siguiente:

• Fichero .fig que contiene la descripción del diseño del GUI y de sus componentes.

• Fichero .m , que contiene el código que controla el GUI, incluyendo los callbacks de todos sus componentes (dinámicos). Más concretamente:

o Inicializa el GUI. o Contiene código para realizar las tareas necesarias antes de que

aparezca el GUI en pantalla, como la creación de datos o gráficos. o Contiene las funciones callback que se ejecutan cada vez que el

usuario hace “clic” en un componente.

Así pues, hay que resaltar que para arrancar un GUI correctamente, se debe ejecutar desde el terminal de instrucciones, pues si ejecutamos solo el fichero .fig, Matlab no lo relaciona con el fichero .m que es el que contiene la estructura handles, los callbacks etc. 3.3.5. Propiedades de los objetos

Dependiendo del objeto, el cual puede tener propiedades específicas, las propiedades generales de estos son las siguientes:

• Nombre (Name): el valor de esta propiedad será la que se muestre cuando la ventana de GUI se ejecute (propiedad de un GUI).

• Título (Title): En el caso del título de un panel, aparece en la parte superior del mismo.

• Etiqueta (Tag): se trata de un identificador único para cada componente, en casos generales tiene preestablecido el valor de %automatic, de esta forma los callbacks se auto generaran con ese nombre.

• Cadena (String): Es una propiedad de muchos objetos, en el caso concreto de los botones permite acceder a la etiqueta, en el caso de los menús acceder a las diferentes opciones o en el caso de una entrada de texto, podremos acceder a lo que ha introducido el usuario.

• Otras muchas propiedades, pero que dependen del objeto en concreto: grosores, tamaños, colores…


3. Anexos

3.3.6. Estructura handles

Como antes hemos comentado, handles se trata de una estructura que se genera automáticamente cuando se ejecuta el GUI, conteniendo las etiquetas de los diferentes elementos que lo conforman. Tenemos a partir de esta estructura:

• Compartir datos entre los callbacks: almacenando datos en la propia estructura handles:

o Ej. handles.datos=x y posteriormente guardando en la misma estructura, guidata(hObject, handles).

• Acceder a los objetos gráficos o a datos adjuntados (como en el caso

anterior). o Ej. x=handles.elemento (podremos cambiar propiedades en caso de

ser un objeto gráfico).


Documents

Generación de señales de radiofrecuencia arbitrariassauron.etse.urv.es/public/PROPOSTES/pub/pdf/898pub.pdfGeneración de señales de radiofrecuencia arbitrarias TITULACIÓN: Ingeniería