4. komplexe Übertragungsfunktion

komplexe Übertragungsfunktion

  • S

    Sodala. Heute Vormittag hab ich mich dann mal drangesetzt und komm schon zum nächsten Problem 🙂

    Also Code ist bis jetzt:

    /********************************/
/*                              */
/*Titel:    Übertragungsfunktion*/
/*von:		***             */
/*                              */
/********************************/

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

struct	cZahl {
		double Re;
		double Im;
};
// Deklarieren eines structs mit den Eigenschaften 'Im' und 'Re'

const double C1 = 4e-12;
const double C2 = 10e-12;
const double L = 0.1e-3;
const double R = 470;
// Deklarieren der vorgegebenen Werte als Konstanten

double omega = 10;
double Y (double omega);

int main (void) {

	struct cZahl cZahl1;
	cZahl1.Re = 0;
	cZahl1.Im = Y(omega);

	struct cZahl cZaehler;
	cZaehler.Re = 0;
	cZaehler.Im = cmulti(Y(omega));

	printf ("%e,%e", cZahl1.Re, cZahl1.Im);

getchar();
return 0;
}

double Y (double omega) {

	double y;
	y = omega*(C2/(1-omega*omega*L*C2)-C1);
	return y;

}

double cmulti (double y) {

	struct cZahl Erg1;
	Erg1.Re  = R * cZahl1.Re;
	Erg1.Im	 = R * cZahl1.Im;

    Jetzt cZahl1 ist kein Bezeichner...????
    Ja is mir schon klar, der Bezeichner ist Re/Im, aber er muss ja wissen welchen er hernehmen soll....

    0
  • ?

    cZahl1 ist in der Funktion cMulti1 nicht verfügbar.

    -> Etwas über den Scope von Variablen nachlesen.

    Wie lange kann man sich eigentlich mit so einer Kindergartenaufgabe beschäftigen?

    0
  • S

    Naja, wenn es so einfach ist, dann tu dir keinen Zwang an und schick mir den Code. Für mich als Anfänger und ohne dem Ziel mit zutiefst mit C zu befassen, reichts schon aus....

    0
  • B

    Ich habe da ein C Projekt für die Uni, dass mich ein wenig überfordert. Ich habe leider noch nicht so viel Ahnung von C und darum bin ich auf Hilfe angewiesen.

    Für mich als Anfänger und ohne dem Ziel mit zutiefst mit C zu befassen...

    Oh je, ist ein bischen wenig Motivation für die Uni, oder nicht ? Nur weil Programmieren nicht dein Hauptfach zu sein scheint, solltest du es nicht ablehnen.

    Was studierst du, wenn ich mal fragen darf?

    Anmerkungen zum Code:
    Grmpf, du versuchst zwei Dinge gleichzeitig was nicht geht. Baue zuerst deine Dateien für den Umgang mit komplexen Zahlen und danach führe erst die Berechnung.

    ...
tComplex MyH(double w)
{
  tComplex R, Y, u2, u1;

  R = Complex_Init(470, 0);
  Y = Complex_Init(0, w*(...));
  u2 = Complex_Mul(R, y);
  u1 = Complex_Mul(R, y);
  u1.Re++;
  return Complex_Div(u2, u1);  
}

    Es ist nicht schwer. Man muss nur wollen. 😉

    0
  • 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
Anmelden zum Antworten