4. komplexe Übertragungsfunktion

komplexe Übertragungsfunktion

  • S

    Hehe, ja der Ehrgeiz steigt, da mich ungelöste Probleme nerven^^

    Ich hab jetz was nahe am Pseudo Code angelehnt geschrieben. Programm geht schon mal ohne Fehler, allerdings bekomm ich jetz noch Null als Werte, was ja auch nicht stimmt. Wenn ich Einzelschritte mache, sehe ich dass u1 und u2 brav berechnet werden. Wie bekomm ich also Die Werte aus meiner Funktion in die main,damit ich sie ausgeben kann?

    #include <stdio.h>
#include <math.h>

//Vorgegebene Werte:
const double C1 = 4e-12;
const double C2 = 10e-12;
const double L = 0.1e-3;
const double R = 470;

//Kreisfrequenz Omega
double omega = 10;

//Definition einer Komplexen Zahl
struct komplexeZahl {
	double Re;
	double Im;
};

//Implementieren von h als komplexe Zahl für return
struct komplexeZahl h;

//Implementieren von Zähler und Nenner
struct komplexeZahl u1; 
struct komplexeZahl u2;

//Funktion für Berechnung
struct komplexeZahl H(double omega) {

	//Implementieren und berechnen von Leitwert
	struct komplexeZahl Y;
	Y.Re = 0;
	Y.Im =  omega*(C2/(1-omega*omega*L*C2)-C1);

	//R*Y
	u2.Re = R * Y.Re;
	u2.Im = R * Y.Im;

	//1+R*Y
	u1.Re = 1 + u2.Re;
	u1.Im = u2.Im;

	return h;
}

int main (void){

	printf("%e,%e", H(10).Re, H(10).Im);

	getchar();
	return 0;
}

    P.S.: Weiss grade nicht ob ich Implementieren und Definieren in ihrer richtigen Bedeutung benutzt habe, aber grad gings nur darum zu wissen was gemacht wird. Um die Richtigkeit der Kommentare kümmere ich mich am Schluss.

    edit: Ich studiere Mechatronik. Informatik war/ist nur ein einsemestriges Fach in dem die Grundlagen von C vermittelt werden sollen.

    0
  • ?

    h wird in der funktion nichts zugewiesen. die division fehlt.

    0
  • L

    Erstens: Nimm bitte die cpp tags, wenn du c Code postest.

    Zweitens: Lies doch mal die Vorlesungsunterlagen / ein Tutorial über die Gültigkeitsbereiche von Variablen. Du hast ein h das du nie brauchst und das global ist, welches von deiner Funktion zurück gegeben wird. Das kann nicht funktionierten.

    Ein kleiner fix (du solltest das aber besser richtig implementieren, anstatt mit all diesen globalen Variablen):

    H(10);
printf("%e,%e", u1.Re, u1.Im);
    0
  • S

    Danke für die schnellen Antworten. Hab die Division eingefügt. Versucht so wenig wie möglich globale Variablen zu benutzen und erst H(10) und dann ausgegben. Ein Problem hab ich noch, weswegen ich vorher h als globale Variable hatte.

    #include <stdio.h>
#include <math.h>

//Vorgegebene Werte:
const double C1 = 4e-12;
const double C2 = 10e-12;
const double L = 0.1e-3;
const double R = 470;

//Kreisfrequenz Omega
double omega

//Definition einer Komplexen Zahl
struct komplexeZahl {
	double Re;
	double Im;
};

struct komplexeZahl H(double omega);

int main (void){
	H(10);
	printf("%e,%e", h.Re, h.Im);

	getchar();
	return 0;
}

//Funktion für Berechnung
struct komplexeZahl H(double omega) {

	//Implementieren und berechnen von Leitwert
	struct komplexeZahl Y;
	Y.Re = 0;
	Y.Im = omega*(C2/(1-omega*omega*L*C2)-C1);

	//Implementieren von Zähler und Nenner
	struct komplexeZahl u1; 
	struct komplexeZahl u2;

	//R*Y
	u2.Re = R * Y.Re;
	u2.Im = R * Y.Im;

	//1+R*Y
	u1.Re = 1 + u2.Re;
	u1.Im = u2.Im;

	//Die Division
	struct komplexeZahl h;
	h.Re = (u2.Re * u1.Re - u2.Im * u1.Im) / (u1.Im * u1.Im + u2.Im * u2.Im);
	h.Im = (u2.Re * u1.Im - u2.Im * u1.Re) / (u1.Im * u1.Im + u2.Im * u2.Im);

	return h;
}

    Der Compiler meckert noch, dass h (bei printf) "Der Bezeichner ""h"" ist nicht definiert.
    Mit der Fehlermeldung kann ich nun gar nichts anfangen. Ich hab h implementiert, h.Im und h.Re definiert und return gemacht...

    0
  • L

    Du gibst zwar h zurück, aber du ignorierst es...

    struct komplexeZahl h; 

h=H(10);
printf("%e,%e", h.Re, h.Im);
    0
  • S

    Ich blicks nicht. Sorry

    In der Funktion

    struct komplexeZahl H (double omega);

    implementiere ich ganz unten h. Dann definiere ich Re und Im durch die Division und dann mach ich damit einen Return. In der Main lass ich H(10) durchlaufen. Somit sollte doch dann in der funktion h berechnet und returned werden. in der print möchte ich dann h anzeigen. Somit habe ich h doch nicht ignoriert.

    Selbst wenn ichs so mach wie du sagst, gehts nicht -.-

    Es gibt 2 Probleme.

    1. So wie es in meinem Code steht: Bezeichnerproblem mit h.

    2. So wie du es gesagt hast und in meinem: 'return': 'int' kann nicht in 'komplexeZahl' konvertiert werden

    Steh ich denn so dermaßen auf der Leitung??

    0
  • ?

    Du musst einfach mal dringend etwas über Scopes, Parameter und Rückgabewerte lesen.

    Der Bezeichner h ist nur lokal in der Funktion verfügbar. Darauf hast Du in main nicht auf magische Weise Zugriff. Der Rückgabewert der Funktion muss einfach wieder in einer anderen Variablen gespeichert werden, so wie lustig gezeigt hat. Deren Name ist dann vollkommen egal.

    0
  • L

    Keine Ahnung wie du da
    'int' kann nicht in 'komplexeZahl' konvertiert werden
    bekommst. Bei mir funktionierts mit den Zeilen die ich oben geschrieben habe (also zumindest kompilierts und es kommt was raus, ob die Werte stimmen musst du selbst beurteilen):

    http://codepad.org/WKH2IqVF

    0
  • S

    Danke, also des Problem glaub ich liegt grad am Compiler...i probiers mal mit nem anderen...

    0
  • S

    Sodala, also mit nem anderem Compiler gehts nun bei mir auch. Ich hab nun folgendes... (Amp, Phase sind ausgerechnet) Umrechnung in dB für Grafik erst mal noch Nebensache, da ich des erst die Sache mit der Grafik kapieren muss 🙂

    #include <stdio.h>
#include <math.h>

//Vorgegebene Werte:
const double C1 = 4e-12;
const double C2 = 10e-12;
const double L = 0.1e-3;
const double R = 470;

//Implementieren von Omega
double omega;

//Definition einer Komplexen Zahl
struct komplexeZahl {
    double Re;
    double Im;
};

//Funktionsprototypen
struct komplexeZahl H(double omega);
double Amplitude (struct komplexeZahl h);
double Winkel (struct komplexeZahl h);

int main (void){
    struct komplexeZahl h;

    for (omega = 4.5e6; omega < 4.5e6 + 70 * 20e3;  omega = omega + 20e3) {

    h = H(omega);

    double Amp = Amplitude(h);
    double Pha = Winkel(h);  

    printf("%lf\n", Amp);
    }

    getchar();
    return 0;
}

//Funktion für Berechnung
struct komplexeZahl H(double omega) {

    //Implementieren und berechnen von Leitwert
    struct komplexeZahl Y;
    Y.Re = 0;
    Y.Im = omega*(C2/(1-omega*omega*L*C2)-C1);

    //Implementieren von Zähler und Nenner 
    struct komplexeZahl u1,u2;

    //R*Y
    u2.Re = R * Y.Re;
    u2.Im = R * Y.Im;

    //1+R*Y
    u1.Re = 1 + u2.Re;
    u1.Im = u2.Im;

    //Die Division
    struct komplexeZahl h;
    h.Re = (u2.Re * u1.Re - u2.Im * u1.Im) / (u1.Im * u1.Im + u2.Im * u2.Im);
    h.Im = (u2.Re * u1.Im - u2.Im * u1.Re) / (u1.Im * u1.Im + u2.Im * u2.Im);

    return h;
}

//Funktion zum Berechnen der Amplitude
double Amplitude (struct komplexeZahl h) {
       double Amp = sqrt((h.Im * h.Im) / (h.Re * h.Re));
       return Amp;
       }

//Funktion zum Berechnen des Winkels
double Winkel (struct komplexeZahl h) {
       double Pha = atan2(h.Im, h.Re);
       return Pha;
       }

    Jetzt soll ich das Ganze als 'Pseudo' Grafik darstellen:

    http://s1.directupload.net/images/111213/temp/bybewc5y.jpg

    Liege ich richtig in der Annahme, dass das in C nur über Schleifen und printf zu realisieren ist. Würde mich sehr freuen wenn ihr mir wieder helfen könntet. Ich mach mich morgen an meinen eigenen Ansatz, sollte ich eine zündende Idee haben, ansonsten bin ich wieder auf Euch angewiesen.

    So long... vielen Dank bisher und im Vorraus.

    scontch

    0
  • ?

    Ich weiß nicht wie Kleinlich Dein Übungsgruppenleiter ist, aber in der Aufgabenstellung war explizit die Rede von Funktionen für die Grundrechenarten für Komplexe Zahlen. Evtl. solltest Du das noch nachholen und diese Funktionen dann für die Teilschritte der Berechnug verwenden.

    Tipp für die grafische Ausgabe:
    "Zeichne" zuerst in ein 2D-char-Array. Dort hast Du wahlfreien Zugriff was die Sache vereinfacht.

    Anschließend iterierst Du "von oben nach unten" über das Array und printest einfach jedes char in die Konsole.

    0
  • S

    Tipp für die grafische Ausgabe:
    "Zeichne" zuerst in ein 2D-char-Array. Dort hast Du wahlfreien Zugriff was die Sache vereinfacht.

    Anschließend iterierst Du "von oben nach unten" über das Array und printest einfach jedes char in die Konsole.

    Also mit 2D array kann ich mir das grad nicht Vorstellen bzw. kapier ich des ned. Ich hatte es mit nen normalen array probiert, aber das geht nur, wenn der erste Wert auch immer des Max. ist und der Letzte das Min.
    Dem ist aber leider nicht so. Der Graph sollte so aussehen.
    http://s7.directupload.net/file/d/2738/i7h7txz6_jpg.htm

    Bei Aufgabe 1 hat sich auch noch ein Problem ergeben, nachdem ich alles mit Funktionen gemacht habe.

    #include <stdio.h>
#include <math.h>

//Deklarieren der Variablen für die Kreisfrequenz
double Pi = 3.141592654;
double f;
double omega;

//Deklarieren der Variablen nach Vorgabe
const double C1 = 4e-12, C2 = 10e-12, L = 0.1e-3, R = 470;

//komplexe Zahl mit Real- und Imaginärteil deklarieren
struct kompZ {
       double Re;
       double Im;
};

//Funktionsprototypen
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2);
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2);
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2);
double Phase (struct kompZ kompZ1);
double Betrag (struct kompZ kompZ1);
struct kompZ kLeitwert (double omega);
struct kompZ H (struct kompZ y);

int main()
{
    for(f = 4.5e6; f <= 4.5e6 + 70 * 20e3; f = f + 20e3) {

	omega = 2 * Pi * f;

	struct kompZ y;
	y = kLeitwert(omega);
	printf("%lf + I %lf\n", y.Re, y.Im);

	struct kompZ h;
	h = H(y);
	printf("H(%lf): %lf + I %lf\n\n\n", omega, h.Re, h.Im);

	}

  	system("PAUSE");	
  	return 0;
}

//Funktion für die komplexe Addidion nach math. Regeln
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2) {
       struct kompZ Erga;
       Erga.Re = kompZ1.Re + kompZ2.Re;
       Erga.Im = kompZ1.Im + kompZ2.Im;
       return Erga;
}

//Funktion für die komplexe Multiplikation mit einem Faktor nach math. Regeln
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2) {
       struct kompZ Ergm;
       Ergm.Re = Zahl1 * kompZ2.Re;
       Ergm.Im = Zahl1 * kompZ2.Im;
       return Ergm;
}

//Funktion für die komplexe Division nach math. Regeln
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2) {
       struct kompZ Ergd;
       Ergd.Re = (kompZ1.Re * kompZ2.Re - kompZ1.Im * kompZ2.Im) / (kompZ2.Re * kompZ2.Re - kompZ2.Im * kompZ2.Im);
       Ergd.Im = (kompZ1.Im * kompZ2.Re - kompZ1.Re * kompZ2.Im) / (kompZ2.Re * kompZ2.Re - kompZ2.Im * kompZ2.Im);
       return Ergd;
}

//Funktion für die Berechnung des Winkels von komplexen Zahlen nach math. Regeln
double Phase (struct kompZ kompZ1) {
       double Pha;
       Pha = atan2(kompZ1.Im, kompZ1.Re);
       return Pha;
}

//Funktion für die Berechnung des Betrags einer komplexen Zahl nach math. Regeln
double Betrag (struct kompZ kompZ1) {
       double Amp;
       Amp = sqrt ( kompZ1.Im * kompZ1.Im + kompZ1.Re * kompZ1.Re);
       return Amp;
}

//1. Berechnung des komplexen Leitwerts
struct kompZ kLeitwert (double omega) {
       struct kompZ y;
       y.Re = 0;
       y.Im = omega * (C2 / (1 - omega * omega * L * C2) - C1);
       return y;
}

//2. Berechnung der Übertragungsfunktion 
struct kompZ H (struct kompZ y) {

      //R * kLeitwert
      struct kompZ u2;
      u2 = kMultiplikation(R,y);

       //1 + R * kLeitwert
       struct kompZ u1;
       struct kompZ eins;
              eins.Re = 1;
              eins.Im = 0;
       u1 = kAddition ( eins , kMultiplikation ( R , y));

       struct kompZ h = kDivision (u2, u1);

       return h;
       }

    kLeitwert (also y) wird noch richtig ausgerechnet, aber H(y) dann leider nicht mehr. Das lässt ja nur den Schluss zu, dass in einer der Funktionen für Addidion, Multiplikation oder Division der Fehler liegen muss, finde dort aber keinen!!

    Hier noch der Vergleich des Programms mit der Berechnung, die Maple ausspuckt:

    http://s7.directupload.net/file/d/2738/5tjs3d7e_jpg.htm

    lg scontch

    0
  • ?

    scontch schrieb:

    Also mit 2D array kann ich mir das grad nicht Vorstellen bzw. kapier ich des ned.

    Jeder Eintrag in dem 2D-Array entspricht einem "Pixel" auf dem Ausgabegerät. Du brauchst also sowas in der Art: char a[70][20]

    Der Vorteil ist folgender: Wenn Du die Kurve zeichnest und ein Sternchen an die Position x,y zu zeichnen hast, kannst Du einfach auf das Array zugreifen: a[x][y] = '*'. Das ist in der Console nicht ohne weiters möglich.

    Anschließend mit zwei Schleifen drüber laufen und alles auf einen Schlag printen.

    0
  • ?

    In kDivision bei der Berechnung von Ergd.Re muss es ein + statt - sein

    0
  • S

    Vielen Dank fürs drüber schauen. Den Fehler hätt ich heute nicht mehr gefunden 😉

    Nach dem Frühstück mach ich mir mal nochmal Gedanken zu dem array...

    0
  • S

    dringendes Problem, bitte um schnelle antworten wenn möglich.

    #include <stdio.h>

int main (void) {

	int Bild [1] [1];
	int i,j;

	Bild [0][0] = '*';
	Bild [1][0] = '*';

	for (i=0;i<=1;i++){
		for (j=0;j<=1;j++){
	if (Bild [i][j] == '*'){
	printf("*");
}
else{
printf("1");
}}}
	getchar();
	return 0;
}

    ich erwarte bei der ausgabe 2 * erhalte aber 3, wieso?
    wenn ich die sternchen in [0] [0] und [1] [1] befülle erhalte ich korrekterweise 2. Wo is der Fehler??

    0
  • B

    Wieviele Elemente hat das Array Bild?

    0
  • S

    Also das Orginal zur Aufgabe soll 70 breit und 20 hoch sein;

    mein beispiel hab ich gelöst.
    ich hab null plan was ich mit der aufgabe machen soll, dass das ein richtiges bild wird.

    das is was ich hab. das bild stimmt null und ich weiss ned warum. wenn ich alles logisch durchgehe sollte es meiner meinung nach passen 😢

    #include <stdio.h>
#include <math.h>

//Deklarieren der Variablen für die Kreisfrequenz
double Pi = 3.141592654;
double f;
double omega;

//Deklarieren der Variablen nach Vorgabe
const double C1 = 4e-12, C2 = 10e-12, L = 0.1e-3, R = 470;

//komplexe Zahl mit Real- und Imaginärteil deklarieren
struct kompZ {
double Re;
double Im;
};

//Funktionsprototypen
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2);
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2);
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2);
double Phase (struct kompZ kompZ1);
double Betrag (struct kompZ kompZ1);
struct kompZ kLeitwert (double omega);
struct kompZ H (struct kompZ y);
double log10(double x);
double min_max (double AmpdB);

int main()
{

double temp;
double max = 20 * log10(Betrag(H(kLeitwert(2 * Pi * 4.5e6))));
double min = max;

double AmpdBtemp [70];
int t = 0;

for(f = 4.5e6; f <= 4.5e6 + 70 * 20e3; f = f + 20e3) {

omega = 2 * Pi * f;

struct kompZ y;
y = kLeitwert(omega);

struct kompZ h;
h = H(y);

double Amp = Betrag(h);
double Pha = Phase(h);

//printf("Omega: %lf\tAmpltiude: %lf\tPhase:%lf\n",omega,Amp,Pha);

double AmpdB = 20* log10(Amp);
//printf("AmpdB: %lf\n\n", AmpdB);

temp = AmpdB;

if (max < temp) {
max = temp;
}

if (min > temp) {
min = temp;
}

AmpdBtemp [t] = AmpdB;
t++;

}
/*
int penis;
for (penis=0; penis<70; penis++)
printf ("%f\n", AmpdBtemp[penis]);
*///Array AmpdBtemp wird richtig befüllt

double step = (min - max) / 20;

char Bild [70] [20];
double point0 = min;
double point1;
int i, j=0;

Bild [0] [0] = '*';
t = 0;
for (i = 1; i < 70; i++) {
point1 = AmpdBtemp [t];
t++;

if (point1 > point0) {

if (point1 - point0 > step ) {
Bild [i] [j+1] = '*';
point0 = point1;
j++;
}

else {
Bild [i] [j] = '*';
point0 = point1;
}
}

else {

if (point0 - point1 > step) {
Bild [i] [j-1] = '*';
point0 = point1;
j--;
}

else {
Bild [i] [j] = '*';
point0 = point1;
}
}
}

int x;
int y;

for (y = 0; y < 19; y++) {

for (x = 0; x < 70 ; x++){ 
if (Bild [x][y] == '*') 
printf("*");
else
{printf (" ");}
}
printf("\n");

}

system("PAUSE");	
return 0;
}

//Funktion für die komplexe Addidion nach math. Regeln
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2) {
struct kompZ Erga;
Erga.Re = kompZ1.Re + kompZ2.Re;
Erga.Im = kompZ1.Im + kompZ2.Im;
return Erga;
}

//Funktion für die komplexe Multiplikation mit einem Faktor nach math. Regeln
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2) {
struct kompZ Ergm;
Ergm.Re = Zahl1 * kompZ2.Re;
Ergm.Im = Zahl1 * kompZ2.Im;
return Ergm;
}

//Funktion für die komplexe Division nach math. Regeln
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2) {
struct kompZ Ergd;
Ergd.Re = (kompZ1.Re * kompZ2.Re - kompZ1.Im * kompZ2.Im) / (kompZ2.Re * kompZ2.Re + kompZ2.Im * kompZ2.Im);
Ergd.Im = (kompZ1.Im * kompZ2.Re - kompZ1.Re * kompZ2.Im) / (kompZ2.Re * kompZ2.Re + kompZ2.Im * kompZ2.Im);
return Ergd;
}

//Funktion für die Berechnung des Winkels von komplexen Zahlen nach math. Regeln
double Phase (struct kompZ kompZ1) {
double Pha;
Pha = atan2(kompZ1.Im, kompZ1.Re);
return Pha;
}

//Funktion für die Berechnung des Betrags einer komplexen Zahl nach math. Regeln
double Betrag (struct kompZ kompZ1) {
double Amp;
Amp = sqrt ( kompZ1.Im * kompZ1.Im + kompZ1.Re * kompZ1.Re);
return Amp;
}

//1. Berechnung des komplexen Leitwerts
struct kompZ kLeitwert (double omega) {
struct kompZ y;
y.Re = 0;
y.Im = omega * (C2 / (1 - omega * omega * L * C2) - C1);
return y;
}

//2. Berechnung der Übertragungsfunktion 
struct kompZ H (struct kompZ y) {

//R * kLeitwert
struct kompZ u2;
u2 = kMultiplikation(R,y);

//1 + R * kLeitwert
struct kompZ u1;
struct kompZ eins;
eins.Re = 1;
eins.Im = 0;
u1 = kAddition ( eins , kMultiplikation ( R , y));

struct kompZ h = kDivision (u2, u1);

return h;
}
    0
  • L

    Bitte rück deinen Code doch vernünftig ein, das ist ja extrem schwierig zu lesen so...
    Aber ich verstehe die Logik auch nicht. Wieso machst du nicht einfach:

    double AmpdBtemp[70];
char Bild [70] [20];
int maxdB,mindB;

/* Berechne AmpdBtemp und die maximal und minimalwerte maxdB und mindB
   [...]*/

/* Initialisiere Bild mit ' '
   [...]*/

for (int i=0; i<70; i++)
{
  int dBValue=(int)((AmpdBtemp[i]-mindB)/(maxdB-mindB)*20); /*Rechne das nochmal nach, damit das auch stimmt*/
  Bild[i][dBValue]='*';
}

/* Hier Bild ausgeben
   [...]*/
    0
  • S

    Meine Logik dahinter war das "dynamische Befüllen des Arrays", da die dritte Aufgabe ist, den Benutzer C1, C2, L und R auswählen zu lassen und dann die Grafik anzupassen. Kann ich des dann auch so machen?

    /* Initialisiere Bild mit ' '
    [...]*/

    Hmm, heißt das, ich soll einfach das ganze Array mit Leerzeichen befüllen, oder wie war des gemeind?

    Sorry für den unübersichtlichen Code. War müde und der Kopf war voll. Der nächste ist Vorbildlich 🙂

    0
Anmelden zum Antworten