für ein Projekt soll ich eine Transistor Kennlinien Kurve in C++ Builder
zeichnen. Die Werte lese ich ein.

Das Prob ist das Zeichnen z.B. dieser Kurve:
http://homepages.fh-regensburg.de/~kej39084/design/images/mos_bild8.jpg

Ich verzweifel an dem Berechnen der Werte:
Hab mir schon ein paar Tuts angeschaut, nur funzten tut nichts, u.a. mit polybezier.
das einzige was funzt ist das zeichnen mit pow, nur sollte es da doch parabolisch aussehen, was es auch nicht tut.

gibts das nicht ein allg. heilmittel zur anzeige von nicht-liniearen funktionen?

vielen dank!

warum trägst du die Werte nicht manuell ein? Canvas hat die Eigenschaft Pixels, als zweidimensionales Array [X][Y] (wobei X von links nach rechts und Y von oben nach unten geht). Du berechnest also die Punkte deiner Funktion selber und setzt jeden einzelnen Pixel in Abhängigkeit von x selber.

bis bald
akari

ich müsste also ein art wertetabelle machen,also arrays aus denen die werte dann gelesen werden, nur wie, keine ahnung!

also
- funktion
- wertetabelle
- canvas (da kommt glaube ich nur polybezier in frage oder?)

daraus errechnet sich dann anhand einer formel wie die kruve verläuft.

und genau das brauchst du um selber die Grafik zu erstellen.
Du gehst auf der Canvas->Fläche, die für dein Diagramm festgelegt ist, von links (X = z.B. 0) nach rechts (X = z.B. 500) und kannst anhand einer Umsetzung Pixel/Messeinheit bestimmen, welchen Wert du aus deiner Funktion bekommst, diesen wieder in Pixel auf Y umrechnen und in Canvas->Pixels[X][Y] einen passenden Farbwwrt setzen.

Du kannst dir aber auch mal das Control TPerformanceGraph aus dem Reiter Beispiel anschauen.

bis bald
akari

// Eingangswiderstand berechnen //

if( verfahren->ItemIndex == 0)
{
if(Ube->Text == "" && Ib->Text == "")
MessageBox(NULL,"Bitte geben Sie die Werte für Ube und IB ein, um den Eingangswiderstnad zu berechnen","Fehler",MB_ICONERROR);
else
wib = StrToFloat(Ib->Text);
wube = StrToFloat(Ube->Text);

ergrbe = wube/wib;

Rbe->Text = FloatToStrF(ergrbe,ffFixed, 7, 2);

for(wube=50; wube<= 400; wube++)
PaintBox1->Canvas->Pixels[wube][pow(wube,wib)] = clRed;
}

könntest du mir evtl. kurz den code so proggen? *ganzliebbittend*
das beispiel ist nur die zeichnerische oberfläche von Tperfor....

danke

I=f(U) { abhaengig vom Parmeter}

???

Was soll das fuer ein Transistor sein?

Vielleicht hilft das etwas:

http://olli.informatik.uni-oldenburg.de/weTEiS/weteis/transistor2.htm

Hab da auch noch ein Dos-geproggtes Prog, das die Werte für elliptische polynome Kurvenverläufe berechnet, nur schlau werd ich daraus nicht.
Funktioniert zwar so weit, nur auf meine Aufgabe kann ichs wahr. nicht anwenden.
heir mal die source:

--------------------------------------------------------------------------------

#include <iostream.h>
#include <math.h>

const int max = 100;

// Basisklasse
class Kurve
{
double xTab[max], yTab[max]; // Tabellen fuer x- und y-Werte
public:
int n; // Anzahl der Punkte
Kurve () {} // Standard-Konstruktor
virtual double x(double) =0; // Dummy-Funktion fuer x-Koordinate
virtual double y(double) =0; // Dummy-Funktion fuer y-Koordinate
void Berechnen (int,double,double); // Deklarationen fuer die
void Ausdrucken (); // Berechnung und Ausgabe einer Wertetabelle
};

void Kurve::Berechnen (int Punkte, double von, double bis)
{
double dt,t; // Schrittweite und Parameter (von..bis)
if (Punkte > max)
{
Punkte = max;
cout << "Warnung, Punkteanzahl auf " << max << " reduziert!" << endl;
}
n = Punkte; // Klassenkomponente definieren
t = von; // Parameter
dt = (bis-von)/(n-1); // Schrittweite berechnen
for (int i=0; i<n; i++, t+=dt) // Wertetabelle berechnen
xTab[i] = x(t), yTab[i] = y(t);
}

void Kurve::Ausdrucken ()
{
// Voreinstellungen fuer die Zahlausgabe, damit die Tabellen schoener aussehen;
// zusaetzlich muss bei jeder Ausgabe cout.width(n) aufgerufen werden,
// damit positives Vorzeichen als Leerzeichen erscheint (andernfalls wird es weggelassen)
cout.setf(ios::showpoint | ios::scientific); // Gleitpunktformat
cout.precision(8); // mit 8 Stellen nach Punkt
for (int i=0; i<n; i++)
{
cout.width(15);
cout << xTab[i] << " ";
cout.width(15);
cout << yTab[i] << endl;
}
}

// =================================================================
// abgeleitete Klasse Ellipse
class Ellipse: public Kurve
{
double a,b; // Halbachsen
public:
Ellipse (double a0, double b0) { a=a0; b=b0; } // Konstruktor
virtual double x(double t) { return a * cos(t); }
virtual double y(double t) { return b * sin(t); }
};

// =================================================================
// abgeleitete Klasse Polynom
class Polynom: public Kurve
{
double a0,a1,a2,a3; // Koeffizienten, max. 3-ter Grad
public:
Polynom (double b0=0,double b1=0,double b2=0,double b3=0)
{ a0=b0; a1=b1; a2=b2; a3=b3; } // Konstruktor
virtual double x(double t) { return t; }
virtual double y(double t)
{ return ((a3*t+a2)*t+a1)*t+a0; }
};

// =================================================================
// Hauptprogramm
int main ()
{
cout << "Ellipse:" << endl;
Ellipse ell(5,2);
ell.Berechnen(10,0,6.2832); // 10 Punkte, 0 bis 2 pi
ell.Ausdrucken();

cout << endl << "Polynom: " << endl;
Polynom pol(-5,1,1); // x*x + x -5
pol.Berechnen(11,-5,5); // 11 Punkte, -5 bis 5
pol.Ausdrucken();

return 0;
}

--------------------------------------------------------------------------------
Die Formel zur Berechnung ist für IC (ids)

idsw = b*((ugsw-uthw)*udsw-((udsw*udsw)/2));

wobei ugsw = UGS (ube)
und udsw = UDS (uce)
und uthw = UTH (schwellwertspannung)
b = verstärkungsfaktor
idsw = IC (kennlinie der stromwerte - diese Kurve soll gezeichnet werden)

irgendwie verstehe ich dein Problem nicht. Du hast deine Formeln, du hast die Darstellungsmöglichkeiten von Canvas. Warum setzt du das denn nicht so um?

bis bald
akari

ja hmm, ich weiß nicht wie ich das den canvas methoden umsetzen kann.

ich möchte eine wertetabelle machen, die für jeden punkt (der ja immer unterschiedlich ist) werte für x (= uce) und y (= ic) ausrechnen lassen.

Diese Punkte sollen dann aneinander gereit gezeichnet werden (also logischerweise mit der methode "pixels" von canvas), das ergibt ja dann automatisch die kennlinie.

ich weiß nun nicht wie ich das anstellen soll?
das proggen der wertetabelle ist mir ehrlich gesagt ein rätsel, sowie die übergabe der einzelnen werte an "Canvas pixels".

ne gerade zeichne ich ja so:

for (int i = 10; i <= 200; i++)
PaintBox1->Canvas->Pixels[i][10] = clRed;

nun müsste ich ja [i] jedesmal den neu errechneten wert von x (= uce) zuweisen, damit da dann der punkt an einer andren stelle gezeichnet wird. nur wie?

danke

nun müsste ich ja [i] jedesmal den neu errechneten wert

nein, das i bleibt genau so wie du es hast, du mußt den y-Wert (bei dir 10) immer neu berechnen.

Jetzt brauchst du einen Maßstab Pixel/Meßwert. Zum Beispiel 1 Pixel entsprechen 5 V (wenn da irgendwo Volt ist). Dann kannst du vom linken Pixel anfangen, indem du den niedrigsten möglichen Ausgangswert in deine Formel einsetzt, also

x = uce(0 * 5); // Pixel mal Maßstab

dann kommt der nächste Pixel

x = uce(1 * 5); // Pixel mal Maßstab

das ganze natürlich in einer Schleife bis zum letzten möglichen Pixel.

Das Ergebnis deiner Rechnung mußt du gegebenfalls wieder mit einem passenden Maßstab verrechnen, um ihn dann anzeigen zu können.

bis bald
akari

float UTH = 1;         //Pinch-Off-Spannung
   float beta = 1;        //Transistor-Verstärkung
   float Step = 0.01;     //Berechnungsschritte 
   float ID;
   float UGS = 3;
   Chart->BottomAxis->Automatic = false;
   Chart->BottomAxis->Minimum = 0;
   Chart->BottomAxis->Maximum = 10;
   Chart->LeftAxis->Automatic = false;
   Chart->LeftAxis->Minimum = 0;
   Chart->LeftAxis->Maximum = 4;
   for(float UDS = 0; UDS<=Chart->BottomAxis->Maximum; UDS+=Step)
   {
      if(UDS < UGS-UTH)                              //Triodenbereich
      {
         ID = beta*((UGS-UTH)*UDS-(pow(UDS,2)/2));
      }
      else                                           //Sättigungsbereich
      {
         ID = (beta/2)*pow(UGS-UTH,2);
      }
      Series1->AddXY(UDS,ID);
   }

mit tchart kenn ich mich gar nicht aus

Viele Grüße

Kann mir jemand sagen welche Formeln ich für einen ganz normalen bipolaren Transistor nehmen soll und wie ich das in meine Schleife einbaue:

die sieht ja so aus mit TChart:

float UTH = 1;         //Pinch-Off-Spannung
   float beta = 1;        //Transistor-Verstärkung
   float Step = 0.01;     //Berechnungsschritte
   float ID;
   float UGS = 3;
   Chart->BottomAxis->Automatic = false;
   Chart->BottomAxis->Minimum = 0;
   Chart->BottomAxis->Maximum = 10;
   Chart->LeftAxis->Automatic = false;
   Chart->LeftAxis->Minimum = 0;
   Chart->LeftAxis->Maximum = 4;
   for(float UDS = 0; UDS<=Chart->BottomAxis->Maximum; UDS+=Step)
   {
      if(UDS < UGS-UTH)                              //Triodenbereich
      {
       //-> FET Formel, die ist ja falsch ID = beta*((UGS-UTH)*UDS-(pow(UDS,2)/2));
      }
      else                                           //Sättigungsbereich
      {
        //-> ID = (beta/2)*pow(UGS-UTH,2);
      }
      Series1->AddXY(UDS,ID);
   }

Ic = Is*exp(UBE/UT)*(1+UCE/UA)

wobei Is: Sperrsättigungsstrom
UA: Early-Spannung
UT: Temperaturspannung (vgl. Diode) bei 20°C 26mV

falls du lieber Ib anstelle von UBE haben möchtest: Ib = Is/B0*exp(UBE/UT)
B0: extraploierte Stromverstärkung für UCE = 0V

Die Formel für den Übergangsbereich weiss ich leider auch nicht, die müsste ähnlich wie jene der Diode sein.
Wenn du dein Projekt für einen Bipolaren brauchst, wieso lieferst du dann ein Beispielbild eine n-Kanal MOS-FET?

Eigentlich trau ich mich gar nicht nochmal zu fragen, nur ich verzweifel langsam. Die Formeln zur Berechnung im vorherigen Teil dieses Beitrags sind nur für FET`s also MOS Feldeffekt Transistoren. Genau das bemerkte ich erst als ich fast alles fertig hatte *rotwerd*

Kann mir jemand sagen welche Formeln ich für einen ganz normalen bipolaren Transistor nehmen soll und wie ich das in meine Schleife einbaue:

das ist mal ein richtig tolles Beispiel wie eine Projektarbeit NICHT ablaufen sollte. Du schreibst eine Software und hast absolut kein Hintergrundwissen über das was Du da machst. Ich meine nicht das Programmieren, sondern die Elektronik. Vielleicht solltest Du Dich zuerst damit befassen, wenn Du das kapiert hast Dich erst dann ans Programmieren machen? Was bringen Dir die vorgekauten Lösungen hier wenn Du letztendlich nichts kapiert hast?
Zur Erinnerung: eine Projektarbeit dient dazu, sich mit einem Problem zu befassen, Problemlösungen selbstständig(!) zu erarbeiten(!), kurz: etwas daraus zu lernen. Dieses Wissen das Du Dir dann daraus erwirbst wirst Du nicht so schnell vergessen....die vorgekauten Lösungen bringen Dir sogesehen gar nichts.

Danke aber für diesen Kommentar, ich denke jetzt werde ich mich mit mehr Gewissen auf mein Projekt stürzen!

Danke auch wedmer! -- Diese Mos-FET Formel habe ich aus einem Tutorial, aber ist eben genau das falsche gewesen, wollte ja bipolare Trans-Kenn-Linien zeichnen!

Danke