Programm für Widestandsberechnung mit Zeichnung

[Drakh]

Hallo,

ich habe ein Projekt bekommen an der Uni mit folgender Aufgabenstellung :

berechnung von elektrischen Widerständen.



Soweit so gut. Da dies meine erste Programmiersprache überhaupt ist (hatte vorher nur bisschen HTML gemacht^^), komm ich nun an einer bestimmten Stelle nicht weiter.

Ich habe mich entschlossen erstmal so vorzugehen das ich noch keine Eingabeaufforderung habe sondern erstmal bestimmte Netzwerke darstellen bzw. ausrechnen lassen will.

Hab einfach mal per Hand einen Resistor gezeichnet aber wie ich den jetzt anhand meiner Testschaltung automatisch anordnen lassen kann, da hab ich keine Ahnung


Könnte mir hier einer vielleicht ein kleinen Tipp geben ?

 

[SlaterB]

tja, ein beliebig verknüpftes Schaltnetz zu malen kann tatsächlich eine schwere Aufgabe sein,
ich bin überrascht, wie locker das formuliert ist,

du kannst es in gewissen Grenzen wie folgt machen:
der Code zum Zeichnen eines Resistors muss in eine Operation abhängig von einer bestimmten Postition,
so dass du mit
paintResistor(20,70);
paintResistor(60,30);
mehrerere Resistoren an verschiedene Stellen malen kannst,

interessanter ist die Hauptanordnung,
da schlage ich vor, von links nach rechts in folgender Form zu malen:

                         R6
                   /           \
                R4
             /      \    R7 /     \
           /                       \
         /                          \
R1-R2-R3
          \                      /
            \                 /
                R5-R8

der erste Resistor auf Höhe 50%, Reihenschaltungen einfach hintereinander (y gleich lassen, x um 30 Pixel erhöhen),
bei Parallel-Schaltungen neue Höhen berechnen, am Anfang 75% und 25%,
wenn aber tiefer geschachtelt parallelgeschaltet wird, dann entsprechend weniger,
für die Aufteilung von R4 nach R6 und R7 gehts von Höhe 25% zu 12.5% + 37.5%

evtl. ist es leichter, wenn du dir deine graphische Fläche wie ein Schachbrett in Zellen aufteilst und in bestimmte Zellen zeichnest

damit sind nicht mehr als eine bestimmte Menge von parallelen Schaltungen möglich,
und selbst das ist noch ziemlich kompliziert wenn du gerade mal anfangen hast paar erste Linien zu malen

 

[Drakh]

Also brauch ich im Canvas einen Konstruktor an dem x und y Koords. übergeben werden ? und er dann je nach x,y Eingabe dort den Resistor zeichnet?

Wie könnte sowas aussehen ? Stehe etwas auf dem Schlauch gerade :-(

 

[SlaterB]

ich dachte eher an nur ein Canvas mit einer

public void paint (Graphics g)
{

paintResistor(20,70);
paintResistor(60,30);
}


statt

public void paint (Graphics g)
{

g.drawRect(100,100,30,10);
g.drawLine(80,105,100,105);
g.drawLine(130,105,150,105);
g.drawString("Ohm",98,95);

}

aber natürlich muss das Canvas alle Resistoren kennen um die Positionen zu berechnen,

--------

mit 'ich kann gar nix'-Postings kommst du aber nicht weit,
ich werde es nicht programmieren

wenn's nicht geht, dann ist die Aufgabe eben nix für dich,
aber wie gesagt: das ist auch eine sehr schwere Aufgabe, sowas sieht man hier selten für Anfänger,
verzweifle nicht wenn du das nicht schaffst, programmiere zumindest den sehr überschaubaren Rest ordentlich, das wäre doch was

 

[Drakh]

Also habe mir folgendes überlegt :



Wenn ich nun in der Serienschaltung noch das Zeichnen selbst irgendwie automatisiere, wäre das ein guter Ansatz ? Oder geht das nicht ?

 

[SlaterB]

ja, das sind durchaus gute Überlegungen,
welche Striche du genau verwendest um einen Resistor schick darzustellen ist wohl nicht die Frage,
male anfangs der Einfachheit halber ein R

ich finde die Positionierung auf dem Gesamtbild interessanter und habe nur dazu bisher geschrieben,
das ist für die einzelnen Komponenten nicht so einfach selbst herauszufinden,
irgendjemand muss den Gesamtüberblick haben und die Komponenten im verfügbaren Raum verteilen/ anordnen

 

[Drakh]

Also wäre der nächste Schritt quasi die die Zeichenmethode (Übergangsweies halt durch ein R dargestellt wie du sagst) und die dazugehörige Positionierung ?

Ich würde jetzt z.b. erstmal in der Resistor Klasse ein Resistor zeichnen. Und dann in der Serienschaltung auf die in Resistor festgelegte Zeichnung zurückgreifen und diese Anordnen ?

Würde sowas gehen ?

 

[SlaterB]

ja



(allgemeine Antwort auf allgemeine Frage)

 

[Drakh]

...

 

[Drakh]

Wie man sieht zeichnet er eigentlich recht schön alle Netzwerke die man eingibt. Gefällt mir soweit recht gut.

Allerdings komme ich nun nicht weiter, da ich nach dutzenden Versuchen zu doof es hinzukriegen das halt die einzelnen Widerstand entsprechend Ihrer Schaltung vernetzt werden.

Also das ne Serienschaltung durch eine Linie verbunden ist, und eine Parallelschaltung halt Parallel durch eine linke und rechte Linie veretzt ist.

Hat da vielleicht einer ein Tipp ? Oder habe ich mich da verhauen ?

Bei der Parallelschaltung hab ich ja recht viele IF-Argumente drinnen, damit die Elemente immer schön mittig angeordnet sind zu einander. Ist das zu kompliziert gemacht ?

An sich stellt sich mir die Frage ob ich eventuell allgemein zu umständlich progammiere?

 

[Drake]

Hallo

ein paar Gedankenansätze:

Jeder Widerstand hat min. einen Vorgänger und min. einen Nachfolger. Hat dieser keinen Vorgänger, ist es der Anfang der Schaltung, fehlt der Nachfolger sind wir am Ende angekommen.

Mit diesen Infos kannst du deine Liste von Widerstanden wunderbar durcharbeiten.

 

[Drakh]

Im Moment zeichnet er alle Schaltungen perfekt wie ich es brauch, nur zeichnet er hat keine "Verknüpfungen" weil ich das irgendwie nicht hinkriege.

Oder bezieht sich Dein Ansatz genau auf dieses Problem ? Weil wenn ja, versteh ich das leider nicht so ganz... (aufgrund meiner wohl nicht vorhanden Programmiererfahrung)

Ich hatte jetzt gedacht ich könnte irgendwo was hinzufügen bzw. abändnert um die Verknüpfunslinien zu zeichen ? Oder muss ich komplett anderes vorgehen ?

Im Moment zieht es so aus z.b.


   R              R


   R              R


Es sollte aber so aussehen :


  --R--      --R--
-|      |----|      |--
  --R--      --R--

Also nur die Linien fehlen.. Die "R"s werden schon als Kästchen Beschriftung richtig angeordnet gezeichnet... nur halt nicht verküpft...

 

[SlaterB]

das mit der Höhe und Breite ist ziemlich schlau, daran hatte ich gar nicht gedacht

ansonsten kannst du von der Idee von Drake aus weiterdenken:
jedes Element sollte einen Anfang und Ende haben, welche verknüpft werden,
der Anfang des ersten Elementes ist ein Sonderfall, den kannst du vorerst ignorieren,
ansonsten hast du bisher die Verknüpfung von zwei Parallelschaltungen,
was wohl der schwerste Fall sein wird, versuche lieber erstmal einfache Serien einfacher Resistoren

du musst zunächst die Elemente für sich erweitern,
statt nur einen Kasten müssen sie nun einen Kasten und eine Linie bis zu einem
definierten Begin- und Endpunkt malen,
für einen Resistor

B1 ---- R1  ---- E1

R1 ist Resistor 1, B1 und E1 sind zwei Punkte (Begin und End), deren Postition du dir merken musst,
die Linien zu diesen Punkten muss das Resistor-Element selber zeichen,

--------

Serie:

B1---Ele1---E1  --- B2---Ele2---E2

die Serie kann darauf vertrauen, dass B1---Ele1---E1 sowie B2---Ele2---E2
schon von den enthaltenen Elementen gezeichet wurden, auch wenn Element1 oder Element2 keine einfachen Resistoren
sondern höhere Elemente sind, das erledigt die Rekursion,
die Serie muss nur noch die Linie zwischen E1 und B2 ergänzen, außerdem ist der Beginpunkt der Serie B1, von Element1 übernommen,
der Endpunkt ist E2,

oder du baust es so, dass E1 genau auf B2 fällt, dann brauchst du gar keine zusätzliche Linie und die Breite steigt auch nicht an
(edit: bei einer Serie aus zwei Parallelschaltungen wie unten gezeichnet wäre das unschön, besser doch eine Linie dazwischen)


---------

Parallelschaltung:

  ----- B1---Ele1---E1  -----
  |                          |
BP                           EP
  |                          |
  ----  B2---Ele2---E2  -----

hier ist etwas mehr zu tun, wieder sind nur B1---Ele1---E1 sowie B2---Ele2---E2 gegeben,
es braucht neue Punkte BP und EP und Linien dorthin,
damit wird die Breite der Parallelschaltung etwas größer als die Breite der einzelnen Elemente
oder du sparst wieder etwas mit

B1---Ele1---E1
|           |
BP          EP
|           |
B2---Ele2---E2

 

[Drakh]

Hallo,

Danke Dir erstmal das Du Dich damit beschäftigst


Hab kurz mal rumgebastelt und in den paintmethoden von Parallel und Series ein paar Linien eingefügt und hab das Prinzip verstanden muss es jetzt optimieren im Moment sieht es so schon gut aus.

Nochmal ne reine Interessensfrage : Ist das ganze nun gut oder eventuell zu umständlich programmiert bzw. um zuviele Ecken gedacht ?


Weil wenn die Zeichnerei fertig ist, was sie ja bald ist denke ich, dann fehlt mir noch eine Eingabemaske.

Oder fehlt mir beim Zeichnen noch etwas außer die Verknüpfungslinien ?

 

[SlaterB]

also ich finde das sehr gut, hätte nicht gedacht dass das so einfach geht,
mit Höhe/ Breite kam die Kontrolle rein, das war ne gute Idee

> Oder fehlt mir beim Zeichnen noch etwas außer die Verknüpfungslinien ?

das weiß niemand außer dem Aufgabensteller, du noch am besen

 

[Drakh]

Mal ne Frage :

Wenn ich sage der Resistor hat eine Breite von z.b. 110, dann positioniert er den Resistor aber irgendwie nicht mittig.


wenn ich dann nun meine Linien zeichne verzieht sich alles weil es z.b. so angeordnet ist :

--------------------
|......... R |
--------------------


So möchte ich meine Resistoren aufrufen wenn ich das von z.b.

Aber er ordnet den Widerstand irgendwie so an :

--------------------
|.....R |
--------------------

Gerade bei Parallelschaltunen ist es halt innerhalb der Schaltungen immer linksversetzt. und so kann ich die schlecht in Reihe Schalten etc.[/quote]

 

[SlaterB]

keine Ahnung was dein Problem ist, wenn 0 nicht da ist wo du es vermutest, dann male doch bei -30,
auch alle anderen Linien hast du punktgenau unter deiner Kontrolle,

wo irgendwas 'mittig positioniert' wird oder gerade nicht wird kann ich nicht erkennen

bei noch offenen Fragen müsstest du genauer werden, idealerweise auch Code posten

 

[Drakh]

Morgen


Nun hab ich aber ein kleines optisches Problem.

http://img528.imageshack.us/my.php?image=netzwerkbl.jpg


Wie man sieht überlagern sich die obersten Elemente der Parallelschaltungselemente (welche ja selber eine

Irgendwie wüßte ich nicht wie ich das ändert kann, da es ja Rekursiv aufgebaut ist oder?



Dann noch eine kurze Wissenfrage :
Wieso müssen die Attribute auf static am Anfang der Resistorklasse stehen wenn ich diese von anderen Klassen aufrufen will ? Ohne static klappts nicht mit static gehts ?
meine z.b.

public static int hoehe = 30;
?

 

[SlaterB]

eine einfache Verbesserung ergibt sich schon, wenn du in Parallel

public int hoehe() {
return a.hoehe() + b.hoehe()+20;
}

verwendst

--------

allerdings wachsen dann die Parallelschaltungen aus einer Parallelschalung + einem einzelnen Resistor unschön auseinander,
da muss noch was getan werden,

aber deinen riesigen Code-Block gehen ich nicht im Detail durch,
der muss weg sonst ist das kein schönes Programm,

mit Klassenname.variablenname kann man nur auf statische Variablen zugreifen, klar,
wenn die Variable nicht statisch ist und zwei Objekt haben in dieser Variable Werte 5 und 7, welcher Wert soll dann zurückgeliefert werden?
nicht-statische Varaiblen kann man mit objekt.variable ansprechen, sonst machts keinen Sinn,

das statische ist ja nicht schlimm, nur solltest du es in geordneten Bahnen kürzen,
schreibe
int ax = Resistor.anfangx;
und für die anderen Variablen ebenso, dann spart du schonmal 50% Code-Länge

außerdem ist es unmöglich, dass da hintereinander
> g.drawLine(Resistor.anfangx+x-Resistor.breite/4+bb+Resistor.linie, Resistor.anfangy-hb/2+y-c, ...);
> //Verbindungsstück Oben, Anfang
> g.drawLine(Resistor.anfangx+x-Resistor.breite/4+bb+Resistor.linie, Resistor.anfangy-hb/2+y-c, ...);
steht

da gehören Variablen her
int xP1 = Resistor.anfangx+x-Resistor.breite/4+bb+Resistor.linie;
int yP1 = Resistor.anfangy-hb/2+y-c;

g.drawLine(xP1, yP1, ...);
//Verbindungsstück Oben, Anfang
g.drawLine(xP1, yP1, ...);

dann wirds langsam lesbar,

wenn du so den Code zu normalen Code machst und noch dazuschreibst, was jeweils passiert,
kann man anfangen darüber nachzudenken

normalerweise dürften für so eine Sache nicht so viele if/ else nötig sein, was ist der Grund dafür?

 

[Drakh]

...

 

[LordLuzifer]

Die if-Abfragen kannst du dir ziemlich einfach sparen.

public int hoehe(){
return 2*Math.max(a.hoehe(),b.hoehe());
}

 

[Drakh]

Hehe... Danke Dir

aber die anderen IF-Abfragen sind nicht kürzbar oder ?

 

[LordLuzifer]

Ist alles ziemlich kompliziert und viel, zu viel, um mich da jetzt reinzuarbeiten
Aber du zeichnest ja überall im Prinzip Rechtecke, oder?
Mit g.drawRectangle(x,y,breite,hoehe) geht es vielleicht einfacher, wenn Höhe und Breite immer gleich sind. Das spart dir die ganzen drawLine()-Aufrufe und verkürzt es, mal ganz abgesehen davon, dass man es dann auch lesen kann

 

[Drakh]

hehe ja das stimmt... allerdings sollen die teile ja aussehen wie Widerstande also sind es schon Rechtecke und Quadrate leider.


Erstmal schon mal vielen lieben Dank an Eure Hilfestellungen !


Er setzt nun die Widerstände, aus der die Parallelschaltung besteht, an der Stelle 0-100 (von der Gesamtbreite 120 aus gesehen) und dann hab ich von 100-120 ne leere Stelle.

Ich würde gerne aber irgendwie
0-10 leere Stelle
10-110 Widestände
110-120 leere Stelle.


Gibts für sowas irgendwie einen Trick ? Oder ein Stichwort wo ich mich dieszbgl. weitergehend informieren kann ? Hoffe mein Problem ist überhaupt verständlich.

 

[LordLuzifer]

Erstmal: wenn du doch Rechtecke zeichnest kannst du ja g.drawRectangle() benutzen, das zeichnet ja Rechtecke (und Quadrate).
Beim zweiten Problem: Du musst, bevor du zeichnest, wissen, um wieviel der kleinere Widerstand verschoben werden soll, und veränderst dann einfach dessen x-Koordinaten beim Zeichnen entsprechend. Die Verschiebung kann sich ja die Parallelschaltung "überlegen" und dann per Methode an die Widerstände weitergeben.

 

[Drakh]

Hallo...


zu den Rechtecken :
Ich zeichne die Rechtecke schon die ganze Zeit mit drawRect(), die Linien mit drawLine sind die Verbindungslinien bzw. die Stummelärmchen die ein Einzelner Widerstand mitbekommt.


Das Problem selbst hab ich heute Nachmittag in den Griff bekommen. Viel rumprobiert und ausprobiert. Das Endergebnis sieht tatsächlich so aus wie du es schreibst. Tricky war nur das halt immer aus optischen Gründen gewährleistet sein muss das die Widerstände in einer Parallelschaltung immer mittig untereinander sind, aber wie gesagt nun klappt alles.

Damit ich hab ich den grafischen Teil abgeschlossen und nun fehlt nur noch die Eingabe von Daten, was aber machbar ist.

Ich bedanke mich recht herzlich für Eure Hilfe !

Wie kann ich ein Haken setzen ?

Gruß
Drakh