Elektronischer Widerstand Linear?

Holger Schieferdecker schrieb:

haben! :o)

Schritten.

Schritten:

150 270 560 1500 2200 5600 12000 22000 47000 82000 150000 270000 680000 1.5e+06 2.7e+06 4.7e+06

So, das musste ich doch einfach mal herausfinden! ;o)

und ohne Dateiausgabe, ggf. also in eine Datei pipen.

/* * main.cpp * * Created on: 03.05.2018 * Author: ed */

#include #include #include #include using std::cout; using std::endl; #include

typedef std::vector< double > td_vector_double; typedef std::vector< td_vector_double > td_mat_double; typedef std::set< int > td_set_int;

void Add(double* pDbl, td_vector_double& VD) { while (*pDbl) { VD.push_back(*pDbl); ++pDbl; } }

int main() {

// die die linearste Verteilung von Widerstandswerten ergibt. // // double DSE_Reihe[]= { // 160, 320, 640, 1280, 2560, 5120, 10240, 20480, 40960, 81920, // 163840, 327680, 655360, 1310720, 2621440, 5242880 // }; // // double E12_Reihe[]= // { // 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 0.0 // };

double RF0[]= { 150, 180, 0}; // 160 double RF1[]= { 270, 330, 0}; // 320 double RF2[]= { 560, 680, 0}; // 640 double RF3[]= { 1200, 1500, 0}; // 1280 double RF4[]= { 2200, 2700, 0}; // 2560 double RF5[]= { 4700, 5600, 0}; // 5120 double RF6[]= { 10000, 12000, 0}; // 10240 double RF7[]= { 18000, 22000, 0}; // 20480 double RF8[]= { 39000, 47000, 0}; // 40960 double RF9[]= { 82000, 0}; // 81920 double RF10[]= { 150000, 180000, 0}; // 163840 double RF11[]= { 270000, 330000, 0}; // 327680 double RF12[]= { 560000, 680000, 0}; // 655360 double RF13[]= { 1200000, 1500000, 0}; // 1310720 double RF14[]= { 2200000, 2700000, 0}; // 2621440 double RF15[]= { 4700000, 5600000, 0}; // 2621440

td_mat_double R_Mat(16); Add(&RF0[0], R_Mat[0]); Add(&RF1[0], R_Mat[1]); Add(&RF2[0], R_Mat[2]); Add(&RF3[0], R_Mat[3]); Add(&RF4[0], R_Mat[4]); Add(&RF5[0], R_Mat[5]); Add(&RF6[0], R_Mat[6]); Add(&RF7[0], R_Mat[7]); Add(&RF8[0], R_Mat[8]); Add(&RF9[0], R_Mat[9]); Add(&RF10[0], R_Mat[10]); Add(&RF11[0], R_Mat[11]); Add(&RF12[0], R_Mat[12]); Add(&RF13[0], R_Mat[13]); Add(&RF14[0], R_Mat[14]); Add(&RF15[0], R_Mat[15]);

double R_Min= 80; double R_Max= 100000; unsigned N_Schalter= 16;

Schalterposition

double Best_Match= std::numeric_limits< double >::max(); // Kleinere Werte sind besser! unsigned Best_Steps= 0; unsigned s, Bit, Pos, i, r; double Leitwert, R, Step, R_Lin, Match; // Variablen vordefinieren beschleunigt die Schleifen bool Run= true; while (Run)

// Zuerst R_Min der aktuellen Kombination bestimmen, sollte

Current_R.clear(); for (s= 1; s < pow(2, N_Schalter); ++s)

// R= 1/(1/R0 + 1/R1 + 1/R2 ... + 1/Rn) Leitwert= 0; Bit= 1; for (Pos= 0; Pos < N_Schalter; ++Pos)

if (s & Bit) Leitwert+= 1.0/R_Mat[Pos][Widerstand[Pos]]; // Wenn der Schalter geschlossen ist (1) Leitwert des aktuellen Widerstands aufaddieren

}

bestimmen

if (R >= R_Min && R

Am 03.05.2018 um 18:52 schrieb Edzard Egberts:

DoDi

die Toleranz angeben.

dessen Toleranz die akzeptable Abweichung vom Sollwert ermitteln.

DoDi

Am 03.05.2018 um 18:52 schrieb Edzard Egberts:

Vermutlich stehe ich gerade auf dem Schlauch, aber kannst Du das bitte

Holger

Parallelschalten verkleinert. Das ergab beim Ausprobieren allerdings

So komplett habe ich das noch nicht durchschaut. Ich habe zwar

Leitwert als Schrittweite erzeugt), aber nicht, warum ich immer noch so

die habe ich mir noch nicht genau angeschaut. Dabei ist das so ein simples Problem!

Ja, das ist recht knifflig - die Toleranz des kleinsten Widerstands

Widerstand zu nehmen, wie vom Andreas vorgeschlagen("E96"), aber was mich hier interessierte, war gerade die beste Abdeckung mit nicht genau

Danke, jetzt ist mir klar, was Du meintest.

Wenn 100 k permanent parallel sind, hast Du insbesondere bei den hohen

Wenn ich das richtig sehe, sollen doch zwischen 80 Ohm und 100 kOhm

6.666.566.667 Ohm parallel schalten. So einen hohen Wert hattest Du vermutlich nicht in der Simulation.

Mit den 4,7 MOhm aus Deinem letzten Programm parallel zu 100 kOhm

parallel zu schalten verschlechtert es nur noch.

Hast Du Dein Programm mal mit den exakten Werten von Axel durchlaufen lassen, also 160, 320, 640 etc.? Wie sieht es dann mit dem Fehler aus?

Holger

Na ja, halbwegs linear mit gleichen Schritten wird halt der Leitwert und

t

vorab aussortiert.

--




/ \  Mail | -- No unannounced, large, binary attachments, please! --

Blick naheliegend erscheint.

Wie schon gesagt, ich sollte vielleicht doch mal selber nachrechnen.

E12-Kombination einen Fehler von 0.91 bei 4338 Schritten. Wie Axel nebenan schreibt, die beste Reihe von Leitwerten muss nicht die beste

Am 03.05.2018 um 18:52 schrieb Edzard Egberts:

summieren. Spart die oft gleichen Divisionen 1.0/R_Mat in jedem

Anteil an der Laufzeit hat.

Holger

Programm muss man nicht abwarten.

*Sicherlich* effizienter!

Die ganzen Kombinationen sind es! Im Originalprogramm (4 Dekaden * 12

Hallo zusammen,

Die Ausgangsfrage "Gibt eine Schaltung mit OP(s) + DA-Wandler, die eine

Programm rennt gerade.

rein nehme wird mir das einfach zu viel.

die die Berechnung vereinfacht/beschleunigt.

100R, 200R, 1K, 2K2...) und der Rest, der sich durch Parallelschalten ergibt ist dann "nice to have".

MfG Ralf

Scherer Ralf schrieb:

bis 6 Schaltern laufen lassen - ob das Ergebnis wirklich so gut ist,

"besten" Kombination.

Na ja, das macht im Plot aus dem Punkt einen Klecks.

man dann wieder in das Programm geben und sich die besten Schalterstellungen heraussuchen. Das ist ja eine Punktwolke, durch die eine Linie geht und gesucht sind die Schalterstellungen, bei denen die