EVAP2

Fasor

Los fasores nos van a permitir trabajar con las funciones senoidales de una forma más fácil en algunas ocasiones como al integrar y al derivar.

Como  se puede ver el voltaje con la expresión: 

con  y una corriente con la expresión 

con  , donde 

Definición de fasor: es una cantidad compleja que se emplea para representar funciones del tiempo que varían de forma senoidal.  es un número complejo con:

1. módulo: la amplitud de la magnitud que representa.
2. fase: la fase de dicha magnitud en t=0.

El fasor se relaciona con las funciones senoidales a través de la siguiente expresión:

Para poder usarlo en las ecuaciones integro-diferenciales se necesita ver cómo responden a esas operaciones.

Aplicación interactiva sobre fasores.

Desde este apartado se puede acceder a una aplicación interactiva que a partir de los parámetros de una función senoidal, hace una representación de ésta, y calcula el fasor y la fase. Los parámetros que la aplicación permite introducir son:

• F_m: es la amplitud de la forma de onda.
• La frecuencia de la función senoidal, expresada en radianes por segundo.
• La fase de la forma de onda, pudiéndose elegir tanto un valor en radianes como en segundos.

Una vez que se han introducido los parámetros deseados por el usuario basta con pulsar la tecla Enter para que la aplicación dibuje la forma de onda resultante y calcule los nuevos resultados.

Aplicación interactiva.

3. Diferenciación con fasores

Si tenemos una función g(t) con su parte real x(t) y su parte imaginaria y(t), y definimos la función:

diferenciando f(t):

Si diferenciamos g(t) y luego tomamos la parte real:

Al final:

Las relaciones que tenemos en la diferenciación son:

4. Integración con fasores

Con la función h(t) definida como la integración de f(t):

Las relaciones que hay en la integración se pueden ver a continuación:

Por lo tanto, se pueden resolver las ecuaciones integro-diferenciales que aparecen en régimen permanente senoidal mediante la utilización de fasores. Esto se debe a que las derivadas y las integrales se transforman en multiplicaciones y divisiones por  y así estas ecuaciones se convierten en algebraicas mediante fasores.

5. Ejemplo de análisis con fasores

Si estas expresiones son el dato o incógnita de un circuito como:

Sabemos que del circuito se puede sacar la siguiente ecuación:

utilizando fasores

1. INICIO DEL ALGORITMO

V = 80 x(cos(53)+Jsen(53))

2. DECLARACION 

V, Vm, cos(a), sen(a)   ....SON REALES

3. ASIGNACION

Vm= 80

cosa=0.6

sena=0.8

4.   PROCESO

V=Vmx(cos(a)+Jsen (a))   

5.RESULTADO

V=48+ 64J

6. FIN DEL ALGORITMO

diagrama de flujo

codificacion

CODIFICACIÓN EN dev C++ :

# include <iostream>

# include <math.h>

using namespace std ;

void sumaDeComplejos ( int , int , int , int , int & , int & ) ;

int main ()

{

 int parteReal [ 3 ] ;

 int parteIma [ 3 ] ;

 int resulReal ;

 int resulIma ;

 char * numeros [] = { "Primer" , "Segundo" , "Tercer" } ;

 cout << "\n\t ============================================= " ;

 cout << "\n\t\t\t SUMA DE COMPLEJOS " ;

 cout << "\n\t =============================================\n\n " ;

 for ( int i = 0 ; i < 3 ; i ++ )

 {

  cout << "\n ------------------------------------------------------ " ;

  cout << "\n Parte Real del " << numeros [ i ] << " Numero : " ;

  cin >> parteReal [ i ] ;

  cout << "\n Parte Imaginaria del " << numeros [ i ] << " Numero : " ;

  cin >> parteIma [ i ] ;

 }

 cout << "\n ------------------------------------------------------ " ;

 /* como la funcion solo suma dos numeros complejos

  primero sumamos lo dos numeros */

 sumaDeComplejos ( parteReal [ 0 ] , parteIma [ 0 ] , parteReal [ 1 ] , parteIma [ 1 ] , resulReal , resulIma ) ;

 /* ahora sumamos el resultado con el ultimo numero complejo */

 sumaDeComplejos ( resulReal , resulIma , parteReal [ 2 ] , parteIma [ 2 ] , resulReal , resulIma ) ;

 cout << "\n ------------------------------------------------------ " ;

 cout << "\n Resultado Parte Real : " << resulReal ;

 cout << "\n Resultado Parte Imaginaria : " << resulIma ;

 cout << "\n ------------------------------------------------------ " ;

 cout << "\n\n\n" ;

 system ( "pause" ) ;

 return 0 ;

}

void sumaDeComplejos ( int real1 , int ima1 , int real2 , int ima2 , int & rReal , int & rIma )

{

 rReal = real1 + real2 ;

 rIma = ima1 + ima2 ;

}

CODIFICACIÓN :

# include <iostream>

# include <math.h.h>

using namespace std ;

void sumaDeComplejos ( int R , int & XL ) ;

int main ()

{

 int parteReal [ R ] ;

 int parteIma [ XL] ;

 int resulReal ;

 int resulIma ;

 char * numeros [R + XL] = { "Primer" , "Segundo" , "Tercer" } ;

 cout << "\n\t ============================================= " ;

 cout << "\n\t\t\t SUMA DE COMPLEJOS " ;

 cout << "\n\t =============================================\n\n " ;

 for ( int i = 0 ; i < 3 ; i ++ )

 {

  cout << "\n ------------------------------------------------------ " ;

  cout << "\n Parte Real del " << numeros [ 10 ] << " Numero : " ;

  cin >> parteReal [ R ] ;

  cout << "\n Parte Imaginaria del " << numeros [ 20 ] << " Numero : " ;

  cin >> parteIma [ XL ] ;

 }

 cout << "\n ------------------------------------------------------ " ;

 sumaDeComplejos ( parteReal [ R ] , parteIma [ X ] ) ;

 cout << "\n ------------------------------------------------------ " ;

 cout << "\n Resultado Parte Real : " << Re ;

 cout << "\n Resultado Parte Imaginaria : " << Im ;

 cout << "\n ------------------------------------------------------ " ;

 Z = R + jXL

 cout << " Z ES EL VECTOR DE IMPEDANCIA

 cout << "\n\n\n" ;

 system ( "pause" ) ;

 return 0 ;

}