Treceți la conținutul principal

AUTOINDUCTIA SI CIRCUITE DE CA complet




//AUTOINDUCTIA
//PRODUCEREA FENOMENULUI DE AUTOINDUCTIE
//FI = L*I
double FI(double L, double I ){
return  L*I;
}

//TEM AUTOINDUSA ea
//ea = -DELTA FI / DELTA t
double ea(double DELTAFI, double DELTAt){
return  -DELTAFI / DELTAt;
}
//DELTA FI / DELTA t > 0 THEN ea < 0 THEN Ia SENS CONTRAR
//DELTA FI / DELTA t < 0 THEN ea > 0 THEN Ia ACELASI SENS

//EXPLICATIA AUTOINDUCTIEI
//ROLUL AUTOINDUCTIEI IN TEHNICA

//STUDIUL TEM DE IND ELMAG

//LEGEA LUI LENZ


//CURENTUL ALTERNATIV

//LEGEA LUI OHM IN CURENT ALTERNATIV

//INDUCTIA INTRO SPIRA CARE SE ROTESTE UNIFORM INTRUN CAMP MAGNETIC OMOGEN


//TEM AC
//FORMULA 61
//e = Em * SIN ALFA
double e(double Em, double ALFA){
return  Em * SIN(ALFA);
}

//OMEGA VITEZA UNGHIULARA
//ALFA UNGHIUL SPIRA VS FORTA
//ALFA = OMEGA * t
double ALFA(double OMEGA, double t){
return OMEGA * t ;
}
//e = Em * SIN OMEGA * t
double e(double Em, double OMEGA,double t){
return  Em * SIN (OMEGA * t );
}
//FORMULA 62
//i = Im * SIN OMEGA * t
double i(double Im, double OMEGA,double t){
return  Im * SIN (OMEGA * t );
}

//TIMPUL T
//f = 1 / T; // Hz
double f(double T ){
return 1 / T ;
}
//f = v


//OMEGA = UNGHI PARCURS * TIMP = 2 * PI / T = 2 * PI * f
double OMEGA(double f ){
return  2 * PI * f;
}
//VALORI EFECTIVE U SI I IN AC
/ I = Im / SQR(2) = 0.707* Im
double I(double Im ){
return  0.707* Im;
}
//U = Um / SQR(2) = 0.707 * Um
double U(double Um ){
return  0.707 * Um;
}


//DEFAZAJUL FI
//FI = OMEGA * t
double FI(double OMEGA, double t){
return  OMEGA * t;
}

//CIRCUITUL DE CURENT ALTERNATIV CU REZISTENTA

//I = U / R
double I(double U, double R){
return  U / R;
}
//W = P*t
double W(double P, double t){
return  P*t ;
}
//P = U*I
double P(double U, double I){
return U*I ;
}// W = U * I * t
double W(double U, double I, double t){
return  U * I * t;
}




//CIRCUIT DE CA CU INDUCTANTA

//FI = L*i
double FI(double L, double i){
return L*i ;
}
//FI = L * Im * SIN OMEGA * t
double FI(double L, double Im, double OMEGA, double t){
return  L * Im * SIN (OMEGA * t );
}

//DEFAZAJ IN URMA A CURENTULUI FATRA DE TENSIUNE CU 90 DE GRADE PI/2 SAU T/4 SFERT DE PERIOADA


//U = OMEGA * L * I
double U(double OMEGA, double L, double I){
return  OMEGA * L * I;
}
//REACTANTA INDUCTIVA
//FORMULA 63
//XL = OMEGA * L = 2 * PI * f * L
double XL(double OMEGA, double L){
return  OMEGA * L;
}
double XL(double f, double L){
return  2 * PI * f * L;
}

//U = XL * I
double U(double XL, double I){
return  XL * I;
}
//I = U /XL
double I(double U, double X ){
return U /X ;
}



//CIRCUITUL DE AC CU INDUCTANTA SI REACTANTA
//XL = OMEGA * L
double XL(double OMEGA, double L){
return  OMEGA * L;
}
//UR = R * I
double UR(double R, double I){
return R * I ;
}
//UL = OMEGA * L * I
double UL(double OMEGA, double L, double I){
return  OMEGA * L * I;
}
//U = SQR(UR^2 + UL^2)
double U(double UR, double UL){
return  SQR(UR^2 + UL^2);
}
//U = SQR((R*i^2) + (OMEGA * L * I )^2)
double U(double R, double i,double OMEGA, double L, double I){
return  SQR((R*i^2) + (OMEGA * L * I )^2);
}
//U = I * SQR(R^2 + (OMEGA * L )^ 2 
double U(double R, double OMEGA, double L){
return  I * SQR(R^2 + (OMEGA * L )^ 2 ;
}
//U = I * Z
double U(double I, double Z){
return  I * Z;
}


//IMEPDANTA Z
//FORMULA 64
//Z = SQR(R^2 + (OMEGA * L)^2)
double Z(double R, double OMEGA, double L){
return SQR(R^2 + (OMEGA * L)^2) ;
}
//FORMULA 65
//I = U / Z
double I(double U, double Z){
return  U / Z ;
}
//FORMULA  66
// P = U * I * COS * FI
double P(double U, double I ,  double FI ){
return  U * I * COS ( FI);
}

//CIRCUIT DE CA CU CAPACITATE
//I = U / XC
double I (double U, double XC ){
return  U / XC;
}
//REACTANTA CAPACITIVA XC

//DEFAZAJ FI TENSIUENA U ESTE DEFAZATA IN URMA CURENTULUI I CU PI/2 SAU T/4 UN SFERT DE PERIOADA

//I = OMEGA * C * U
double I(double OMEGA, double C, double U){
return  OMEGA * C * U;
}
//I = U / 1 / (OMEGA * C)
double I(double U, double OMEGA, double C ){
return  U / 1 / (OMEGA * C);
}
//XC = 1 / (OMEGA *C)

double XC(double OMEGA , double C){
return (OMEGA *C)
 ;
}



//CIRCUIT CA CU REZISTENTA , INDUCTANTA SI CAPACITATE

//UR IN FAZA CU CURENTUL
//UR = R * I 
double UR(double R, double I ){
return  R * I;
}
//UL DEFAZAT CU PI/2 INAINTEA CURENTULUI
//UL = OMEGA * L * I
double UL(double OMEGA, double L, double I){
return  OMEGA * L * I;
}
//UC DEFAZATA CU PI /2 IN URMA CURENTULUI
//UC = 1 /(OMEGA *C)*I
double UC(double OMEGA, double C, double I){
return  1 /(OMEGA *C)*I;
}
//U^2 = UR^2  + ( UL - UC ) ^2 = (R * I)^2 + (OMEGA * L ( I - 1 / OMEGA * C * I )^2 = I^2*[R^2 + (OMEGA * L - (1/OMEGA * C))^2]
double U2(double UR, double UL, double UC){
return  UR^2  + ( UL - UC )^2;
}
double U2(double R, double I, double OMEGA, double, L, double C){
return  (R * I)^2 + (OMEGA * L ( I - 1 / OMEGA * C * I )^2;
}
double U2(double R, double I, double OMEGA, double, L, double C){
return  I^2*[R^2 + (OMEGA * L - (1/OMEGA * C))^2];
}

//FORMULA 68
//I = U / (SQR(R^2 + ((OMEGA * L) - (1/(OMEGA*C)))^2);
double I(double U, double R, double I, double OMEGA, double, L, double C ){
return  U / (SQR(R^2 + ((OMEGA * L) - (1/(OMEGA*C)))^2);;
}
//I = U /Z
double I(double U, double Z){
return   U /Z;
}


//IMPEDANTA RLC Z OHM
//DEFAZAJUL FI
//TG FI = ((OMEGA * L) -( 1 / (OMEGA * C)))/R;
double FI(double OMEGA, double L, double C, double R){
return  ((OMEGA * L) -( 1 / (OMEGA * C)))/R;
}
//COS FI = R /Z
double COSFI(double R , double Z){
return R /Z ;
}
//P = U * I * COS FI
double P(double U, double I, double FI){
return  U * I * COS (FI);
}
//OMEGA = 2 * PI * f ; //RAD/S
double OMEGA(double f ){
return  2 * PI * f ;
}
//XL = OMEGA * L;
double XL(double OMEGA, double L){
return OMEGA * L ;
}
//XC = 1 / (OMEGA * C)
double XC(double OMEGA, double C){
return  1 / (OMEGA * C);
}
//Z CURENT = SQR(R^2 + ( XL - XC)^2)
double ZI(double R, double XL, double XC){
return  SQR(R^2 + ( XL - XC)^2) ;
}
//U COS FI = UR = R * I
double COSFI(double UR, double R, double I){
return  UR = R * I;
}
//P = R * I ^2
double P(double R, double I){
return  R * I ^2;
}


//CURENTUL TRIFAZAT
//GENERATORUL DE CURENT TRIFAZAT
//DEFAZARE TENSIUNE TEM AC LA  130o INTRE ELE
// 1/3 DIN PERIOADA ADICA 130 * (2 * PI / 3)

const sfertperioada 130 * (2 * PI / 3)
//SISTEM TRIFAZIC
//UNDE f ESTE ACEASI


//CONEXIUNEA IN STEA
//CONEXIUNE RIUNGHI



//GENERATOARE
//MOTOARE
//TRANSFORMATOARE
//MASINI ELECTRICE DE DC



//PRINCIPIUL GENERATORULUI DE DC
//E = K * v * N * FI * 10^-8 ;//V
double E(double k, double  v,double N, double FI){
return K * v * N * FI * 10^-8 ;
}
//K COEF CONSTR MASINA
//v ROTATII PE SECUNDA
//N NR SPIRE
//FI FLUX MAGNETIC





//CONSTRUCTIA MASINILOR DE DC
//P = E * I
double P(double E, double I){
return  E * I;
}

//REVERSIBILITATEA MASINILOR DE DC

//U = Ei - Ii*ri
double U(double Ei, double Ii, double ri){
return  Ei - Ii*ri;
}
//I2 = E2 - U / r2
double I2(double E2, double U, double r){
return E2 - U / r2 ;
}
//U = E + R*I
double U(double E, double R,double I){
return  E + R*I;
}

//MOTORUL EELCTRIC DE DC
// I = U = E / r + Rp
double I(double E, double r,double Rp ){
return  E / r + Rp;
}
double U(double E, double r,double Rp ){
return  E / r + Rp;
}

//RANDAMENTUL
//NIU = P / P'
double NIU(double P, double Pp){
return P / Pp ;
}
//P' = P / NIU
double Pp(double p, double niu){
return  P / NIU;
}
// I = P' / U
double I(double Pp, double U){
return Pp / U ;
}
// I = U - E / r
double I(double U, double E, double r ){
return  U - E / r;
}
//E = U - Ir
double E(double U, double Ir){
return  U - Ir;
}
//Ip = U / r + Rp
double Ip(double U, double r, double Rp){
return U / r + Rp ;
}
//r + Rp = U / Ip
double rRp(double U, double Ip){
return  U / Ip;
}
double UIp(double r, double Rp){
return  r + Rp;
}


//MASINILE ELECTRICE DE AC
//GENERATORUL DE AC
//v = p * n / 60 ; //Hz
double v(double p, double n){
return  p * n / 60;
}
//REVERSIBILITATEA MASINILOR SINCRONE
//MOTOARE ASINCRONE


//TRANSFORMATOARE DE CURENT
//TRANSFORMATORUL
//NIU = U1*I / U*I = U1 / U = U - R*I / U = 1 = R*I / U
double NIU(double U1, double I, double U){
return U1*I / U*I ;
}
double NIU(double U, double R, double I, double U){
return U - R*I / U  ;
}
double NIU(double R, double I, double U){
return R*I / U  ;
}
//RAPORT DE TRANSFORMARE
//K1 = E1/E2= n1 / n2
double K1(double E1, double E2){
return  E1/E2;
}
double K1(double n1, double n2){
return  n1 / n2;
}
//U1 APROX E1
//U1 / U2 = n1 / n2
double U1PU2(double n1, double n2){
return  n1 / n2;
}
double n1pn2(double U1, double U2){
return  U1 / U2;
//P1 = P2
//U1I1 = U2I2
double U1OI1(double U2, double I2){
return  U2I2;
}
double U2OI2(double U1, double I1 ){
return  U1I1;
}
//I1/I2 = U2 /U1 = n2 / n1
double I1PI2(double U2, double U1 ){
return  U2 /U1;
}
double U2PU1(double I1 , double I2){
return  I1/I2;
}
double I1PI2(double n2, double n1){
return  n2 / n1;
}



































Comentarii

Postări populare de pe acest blog

program principal cpp

#include "clasa.h" #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> #define DELAY 9000000 void delay() { for(long i=0;i<DELAY;i++); } //constructor cu initializare de la tastatura BigInt::BigInt() {char x; signed char t[400]; int i; printf("\nNumarul cu semn "); do s=getche(); while((s!='+')&&(s!='-')); n=0; do {x=getche(); t[n]=x-'0'; n++; } while((x>='0')&&(x<='9')); n--; for(i=0;i<n;i++) nr[i]=t[n-i-1]; } //constructor cu initializare prin parametri BigInt::BigInt(char semn,signed char numar[],int dim) {int i; s=semn; n=dim; for(i=0;i<n;i++) nr[i]=numar[n-i-1]; } //transform un int negativ in pozitiv int BigInt::Pozitiv(int x) {int a,vb; a=0; vb=0; while(vb==0) if((x+a)==0) vb=1; else a=a+1; x=a; return x; } //constructor dintr-un nr int obisnuit BigInt::BigInt(int x) {int i; if(x>=0) s='+'…

NUMERE PRIME ALGORITM C++

// NUMERE PRIME ALGORITM C++//  reediting from scratch //on this page is just the study for a next algoritm for generating the parime nr series like Fibonnaci or ....if possibile

74111121313417374414124343447 if u know the red part you can generate the orange part
1 0 1 111112222 1 1 23

o aplicatie php localitati romania

//APLICATIA SE REFERA LA BAZA DE DATE SIRUTA

//dragtable.js


/* dragtable v1.0 June 26, 2008 Dan Vanderkam, http://danvk.org/dragtable/ http://code.google.com/p/dragtable/ \Bsortabledraggable\B Instructions: - Download this file - Add <script src="dragtable.js"></script> to your HTML. - Add class="draggable" to any table you might like to reorder. - Drag the headers around to reorder them. This is code was based on: - Stuart Langridge's SortTable (kryogenix.org/code/browser/sorttable) - Mike Hall's draggable class (http://www.brainjar.com/dhtml/drag/) - A discussion of permuting table columns on comp.lang.javascript Licensed under the MIT license. */ // Here's the notice from Mike Hall's draggable script: //***************************************************************************** // Do not remove this notice. // // Copyright 2001 by Mike Hall. // See http…