Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > de.sci.electronics > #243216 > unrolled thread

Elektronischer Widerstand Linear?

Started byScherer Ralf <RS.2007@gmx.de>
First post2018-04-24 20:35 +0200
Last post2018-05-24 20:28 +0200
Articles 20 on this page of 77 — 22 participants

Back to article view | Back to de.sci.electronics

Contents

  Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-04-24 20:35 +0200
    Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-24 20:46 +0200
      Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-25 06:00 +0200
        Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-04-26 20:56 +0200
          Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-27 06:39 +0200
            Re: Elektronischer Widerstand Linear? Heiko Lechner <no.spam.to.me@arcor.de> - 2018-04-27 10:19 +0200
    Re: Elektronischer Widerstand Linear? Hans-Peter Diettrich <DrDiettrich1@aol.com> - 2018-04-24 23:11 +0200
    Re: Elektronischer Widerstand Linear? Markus Faust <mfaust@htwm.de> - 2018-04-24 21:19 +0000
      Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-04-26 22:54 +0200
        Re: Elektronischer Widerstand Linear? Bernd Laengerich <Bernd.Laengerich@web.de> - 2018-04-27 10:28 +0200
    Re: Elektronischer Widerstand Linear? Ole Jansen <remove.this.kaspernasebaer@gmx.de> - 2018-04-25 08:09 +0200
    Re: Elektronischer Widerstand Linear? Falk Dµebbert <falk@duebbert.com> - 2018-04-26 11:48 +0200
      Re: Elektronischer Widerstand Linear? Hans-Peter Diettrich <DrDiettrich1@aol.com> - 2018-04-26 12:39 +0200
      Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-04-26 21:27 +0200
        Re: Elektronischer Widerstand Linear? Gerrit Heitsch <gerrit@laosinh.s.bawue.de> - 2018-04-26 21:32 +0200
        Re: Elektronischer Widerstand Linear? Olaf Schultz <o.schultz@enhydralutris.de> - 2018-04-26 21:39 +0200
        Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-04-28 15:56 +0200
          Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-04-28 19:59 +0200
          Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-05-01 18:24 +0200
            Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-01 19:52 +0200
              Re: Elektronischer Widerstand Linear? Axel Berger <Spam@Berger-Odenthal.De> - 2018-05-01 20:18 +0200
                Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-02 08:08 +0200
                  Re: Elektronischer Widerstand Linear? Axel Berger <Spam@Berger-Odenthal.De> - 2018-05-02 15:09 +0200
                    Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-02 15:55 +0200
                      Re: Elektronischer Widerstand Linear? Axel Berger <Spam@Berger-Odenthal.De> - 2018-05-02 17:35 +0200
                        Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-03 09:03 +0200
                          Re: Elektronischer Widerstand Linear? Holger Schieferdecker <spamless@gmx.de> - 2018-05-03 09:35 +0200
                            Re: Elektronischer Widerstand Linear? Andreas Neumann <an5275@sedo.com> - 2018-05-03 16:34 +0200
                            Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-03 18:52 +0200
                              Re: Elektronischer Widerstand Linear? Hans-Peter Diettrich <DrDiettrich1@aol.com> - 2018-05-04 10:47 +0200
                                Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-04 11:15 +0200
                                  Re: Elektronischer Widerstand Linear? Hans-Peter Diettrich <DrDiettrich1@aol.com> - 2018-05-04 14:30 +0200
                                    Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-04 16:12 +0200
                              Re: Elektronischer Widerstand Linear? Holger Schieferdecker <spamless@gmx.de> - 2018-05-04 15:08 +0200
                                Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-04 15:39 +0200
                                  Re: Elektronischer Widerstand Linear? Holger Schieferdecker <spamless@gmx.de> - 2018-05-04 16:27 +0200
                                    Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-04 17:13 +0200
                                  Re: Elektronischer Widerstand Linear? Axel Berger <Spam@Berger-Odenthal.De> - 2018-05-04 16:43 +0200
                              Re: Elektronischer Widerstand Linear? Holger Schieferdecker <spamless@gmx.de> - 2018-05-04 17:37 +0200
                                Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-07 08:09 +0200
                  Re: Elektronischer Widerstand Linear? Wolfgang Martens <na3506b2013@t-online.de> - 2018-05-03 00:55 +0200
      Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-27 10:20 +0200
        Re: Elektronischer Widerstand Linear? Matthias Weingart <mwnews@pentax.boerde.de> - 2018-04-27 12:50 +0000
          Re: Elektronischer Widerstand Linear? Klaus Butzmann <kb.usenet@butzomail.de> - 2018-04-27 15:04 +0200
            Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-04-27 23:31 +0200
              Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-28 00:46 +0200
              Re: Elektronischer Widerstand Linear? Klaus Butzmann <kb.usenet@butzomail.de> - 2018-04-28 10:20 +0200
                Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-04-28 19:02 +0200
                  Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-28 19:52 +0200
                    Re: Elektronischer Widerstand Linear? Andreas Fecht <forum@aftec.de> - 2018-04-28 21:15 +0200
                      Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-28 21:36 +0200
                        Re: Elektronischer Widerstand Linear? Andreas Fecht <forum@aftec.de> - 2018-04-28 22:11 +0200
                          Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-28 22:46 +0200
                        Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-05-01 15:33 +0200
                    Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-04-28 22:57 +0200
                      Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-28 23:09 +0200
                        Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-04-29 10:11 +0200
                          Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-29 10:16 +0200
                        Re: Elektronischer Widerstand Linear? Andreas Fecht <forum@aftec.de> - 2018-04-29 11:00 +0200
                          Re: Elektronischer Widerstand Linear? Dieter Wiedmann <dieter.wiedmann@t-online.de> - 2018-04-29 11:06 +0200
                          Re: Elektronischer Widerstand Linear? Newdo <Newdo@ifmd.de> - 2018-04-29 11:58 +0200
                            Re: Elektronischer Widerstand Linear? Andreas Fecht <forum@aftec.de> - 2018-04-29 12:34 +0200
                          Re: Elektronischer Widerstand Linear? Newdo <Newdo@ifmd.de> - 2018-04-29 13:08 +0200
                            Re: Elektronischer Widerstand Linear? "horst.d.winzler" <horst.d.winzler@web.de> - 2018-04-29 13:35 +0200
                          Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-05-01 15:34 +0200
                            Re: Elektronischer Widerstand Linear? Andreas Fecht <forum@aftec.de> - 2018-05-01 18:58 +0200
                    Re: Elektronischer Widerstand Linear? Klaus Butzmann <kb.usenet@butzomail.de> - 2018-04-29 00:04 +0200
                  Re: Elektronischer Widerstand Linear? Klaus Butzmann <kb.usenet@butzomail.de> - 2018-04-29 00:03 +0200
                    Re: Elektronischer Widerstand Linear? Rolf Bombach <rolfnospambombach@invalid.invalid> - 2018-05-01 15:40 +0200
        Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-05-01 19:12 +0200
      Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-05-01 18:49 +0200
    Re: Elektronischer Widerstand Linear? Matthias Weingart <mwnews@pentax.boerde.de> - 2018-04-26 09:56 +0000
      Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-26 18:24 +0200
        Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-04-26 21:47 +0200
          Re: Elektronischer Widerstand Linear? Rafael Deliano <rafael_deliano@arcor.de> - 2018-04-27 08:05 +0200
    Re: Elektronischer Widerstand Linear? Scherer Ralf <RS.2007@gmx.de> - 2018-05-24 18:44 +0200
      Re: Elektronischer Widerstand Linear? Edzard Egberts <news@edzeg.net> - 2018-05-24 20:28 +0200

Page 1 of 4  [1] 2 3 4  Next page →

#243216 — Elektronischer Widerstand Linear?

FromScherer Ralf <RS.2007@gmx.de>
Date2018-04-24 20:35 +0200
SubjectElektronischer Widerstand Linear?
Message-ID<fk9bniFa8csU1@mid.individual.net>
Hallo zusammen,

Gleich vorne weg:
Ich will keine 100A fließen lassen, 5mA würden es schon tun.

Jeder kennt die typische Schaltung mit der eine elektronische Last ( 
U-Konstant, Poti, OP, Transistor/FET, Stromshunt) gebaut wird.
Wird das Potis an die Eingangsspannung geklemmt wird daraus ein 
einstellbarer Widerstand.
Soweit, so gut.
Wenn ich jetzt anstelle des Potis einen DA-Wandler klemme kann ich das 
per uP steuern, aber ! ich bekomme die 1/n Kennlinie, also nicht linear.

Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?

Eine gute Woche
Ralf

[toc] | [next] | [standalone]

#243218

FromRafael Deliano <rafael_deliano@arcor.de>
Date2018-04-24 20:46 +0200
Message-ID<pbnu29$rr4$1@dont-email.me>
In reply to#243216
 >  5mA würden es schon tun.

Antiker "multiplying DAC" a la PMI DAC10 mit 2,5mA kann in
der Anwendung nicht verwendet werden ?

MfG  JRD

[toc] | [prev] | [next] | [standalone]

#243234

FromRafael Deliano <rafael_deliano@arcor.de>
Date2018-04-25 06:00 +0200
Message-ID<pbougn$p5l$1@dont-email.me>
In reply to#243218
/ Sorry, wie so oft, fehlt mindestens eine Angabe:
/ Es soll ein Widerstand von 80Ohm bis ? sagen wir mal
/ min. 4k simuliert werden, Auflösung min 0.3 Ohm.
/ Dazu dürften die 10Bit nicht reichen.
/ Aber, ich schau mir das Teil mal an (AD baut den
/ sogar noch) evtl. gibts ja was in der Art.
/ Danke Ralf

Typische Schaltung wenn eine Seite GND:
http://www.embeddedFORTH.de/temp/SIM-R.pdf

MfG JRD

[toc] | [prev] | [next] | [standalone]

#243282

FromScherer Ralf <RS.2007@gmx.de>
Date2018-04-26 20:56 +0200
Message-ID<fkelncFg6hfU2@mid.individual.net>
In reply to#243234
On 25/04/18 06:00, Rafael Deliano wrote:
> / Sorry, wie so oft, fehlt mindestens eine Angabe:
> / Aber, ich schau mir das Teil mal an (AD baut den
> / sogar noch) evtl. gibts ja was in der Art.
> Typische Schaltung wenn eine Seite GND:
> http://www.embeddedFORTH.de/temp/SIM-R.pdf

Ah, oh, blätter... in meinem Tietze und Schenk 9. Auflage (ups 1990, 
Merde, die Zeit fliegt) haben sie das wohl gestrichen.
Man, wo zum Henker hast Du das gefunden? Ich google mir einen ab?
Ist das mittlerweile eigentlich schon ein stehender Begriff?
"AbGoogeln"?
Und warum sehe ich meine eigenen Posts nicht in der NG?
Alles wurscht, wie der Pfälzer zu sagen pflegt, danke!, für Deine Info!!

MfG
Ralf

[toc] | [prev] | [next] | [standalone]

#243295

FromRafael Deliano <rafael_deliano@arcor.de>
Date2018-04-27 06:39 +0200
Message-ID<pbu9ip$mv7$1@dont-email.me>
In reply to#243282
> Und warum sehe ich meine eigenen Posts nicht in der NG?

Das Mysterium ist leicht zu lösen:
in Thunderbird ist "antworten" vor "newsgroup antworten".

MfG JRD

[toc] | [prev] | [next] | [standalone]

#243298

FromHeiko Lechner <no.spam.to.me@arcor.de>
Date2018-04-27 10:19 +0200
Message-ID<pbumeb$8fh$1@news.albasani.net>
In reply to#243295
Am 27.04.2018 um 06:39 schrieb Rafael Deliano:

> Das Mysterium ist leicht zu lösen:
> in Thunderbird ist "antworten" vor "newsgroup antworten".

Rechtsklick in die Leiste -> Anpassen -> den Button "Smart antworten" an
die entsprechende Stelle schieben.

[toc] | [prev] | [next] | [standalone]

#243226

FromHans-Peter Diettrich <DrDiettrich1@aol.com>
Date2018-04-24 23:11 +0200
Message-ID<fk9kssFcaaqU1@mid.individual.net>
In reply to#243216
Am 24.04.2018 um 20:35 schrieb Scherer Ralf:

> Soweit, so gut.
> Wenn ich jetzt anstelle des Potis einen DA-Wandler klemme kann ich das 
> per uP steuern, aber ! ich bekomme die 1/n Kennlinie, also nicht linear.
> 
> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?

Digitale Potentiometer gibt es als fertige Chips zu kaufen.

DoDi

[toc] | [prev] | [next] | [standalone]

#243229

FromMarkus Faust <mfaust@htwm.de>
Date2018-04-24 21:19 +0000
Message-ID<pbo70t$frb$1@news.albasani.net>
In reply to#243216
Am 24.04.2018 um 18:35 schrieb Scherer Ralf:
> Hallo zusammen,
> 
> Gleich vorne weg:
> Ich will keine 100A fließen lassen, 5mA würden es schon tun.
> 
> Jeder kennt die typische Schaltung mit der eine elektronische Last ( 
> U-Konstant, Poti, OP, Transistor/FET, Stromshunt) gebaut wird.
> Wird das Potis an die Eingangsspannung geklemmt wird daraus ein 
> einstellbarer Widerstand.
> Soweit, so gut.
> Wenn ich jetzt anstelle des Potis einen DA-Wandler klemme kann ich das 
> per uP steuern, aber ! ich bekomme die 1/n Kennlinie, also nicht linear.
> 
> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?

Widerstand proportional zum DAC-Wert, hab ich das richtig eingesehen?
Logischerweise hätte das Ding dann bei Stellung 0 auch Widerstand 0.

Ohne es ausprobiert zu haben:
Vielleicht könnte man einen multiplizierenden DAC / elektronisches Poti 
zwischen Shunt und OPV-Eingang schalten...
(Weiß nicht, wie sich das auf die Stabilität der Schaltung auswirkt.)

HTH Markus

[toc] | [prev] | [next] | [standalone]

#243292

FromScherer Ralf <RS.2007@gmx.de>
Date2018-04-26 22:54 +0200
Message-ID<a688e20d-2256-88d3-824a-2f75ef5d1f86@gmx.de>
In reply to#243229
Hai Markus,

zuerst, bitte entschuldige, dass/wenn mein Post als PM raus ging, ich 
habe erst heute festgestellt, das Thunderbird den ReplyTo benutzt und 
nicht die NewsGroup. Jetzt versuche ich das manuell zu korrigieren. 
Hoffe das hilft.
Der Grund, warum ich mir einen NewsAccount zugelegt habe ist u.a. das 
es, für mich leichter ist dem Diskussionsfaden zu folgen.
Und ich finde die Diskussionen in der Gruppe gut und wichtig.
Durch meine PMs, ist das jetzt Tonne. Merde!

On 25/04/18 21:39, Markus Faust wrote:
>> Damit würde ich in den Istwert der Regelung eingreifen und den 
>> Sollwert fest auf auf die LastSpannung hängen. Keine Ahnung ob das geht.
> 
> Die Schaltung in dem von Rafael geposteten PDF (Bild 3/4) bildet 
> ziemlich genau das ab.
> 
> Ein potentielles Problem dabei ist, dass Du ziemlich in der Verstärkung 
> des Regelkreises herummanipulierst (mit allen Konsequenzen, die das hat).
> Das ist dem Autor des PDFs sicherlich auch aufgefallen, immerhin ist die 
> Regelung ziemlich totgebremst (C10, C13).
> 
> Weiß nicht, ob es für Deine Zwecke ausreichend ist.

Wenn das Ding von einem Wert zum anderen nicht mehr als ~100ms benötigt 
ist das erst mal egal. 0.4 Ohm entspricht ~1°C PT100
Aber diese Schaltung sieht auf den ersten Blick genau so aus wie ich mir 
das vorstelle: leicht wirr, aber am Ende geht sie.

Vielen Dank,
Ralf

[toc] | [prev] | [next] | [standalone]

#243300

FromBernd Laengerich <Bernd.Laengerich@web.de>
Date2018-04-27 10:28 +0200
Message-ID<fkg59jFpvocU1@mid.individual.net>
In reply to#243292
Am 26.04.2018 um 22:54 schrieb Scherer Ralf:

> NewsGroup. Jetzt versuche ich das manuell zu korrigieren. Hoffe das hilft.
> Der Grund, warum ich mir einen NewsAccount zugelegt habe ist u.a. das es, für 
> mich leichter ist dem Diskussionsfaden zu folgen.
> Und ich finde die Diskussionen in der Gruppe gut und wichtig.
> Durch meine PMs, ist das jetzt Tonne. Merde!

TB lässt sich da leicht umkonfigurieren, Rechtsklick neben den 
Antworten-Button und dann "Anpassen". Da dann den "Antworten"-Button in das 
"Symbolleiste anpassen"-Fenster ziehen, es sollte nur "Smart antworten" drin 
bleiben. Fertig!

Bernd

[toc] | [prev] | [next] | [standalone]

#243239

FromOle Jansen <remove.this.kaspernasebaer@gmx.de>
Date2018-04-25 08:09 +0200
Message-ID<fkakdaFihnrU1@mid.individual.net>
In reply to#243216
Am 24.04.2018 um 20:35 schrieb Scherer Ralf:
> Wenn ich jetzt anstelle des Potis einen DA-Wandler klemme kann ich das 
> per uP steuern, aber ! ich bekomme die 1/n Kennlinie, also nicht linear.

Wenn es nicht schnell sein muss und Du eh einen µC hast: 10Gang
Poti+Schrittmotor? Das ist das 'linearste' was ich kenne.

O.J.

[toc] | [prev] | [next] | [standalone]

#243273

FromFalk Dµebbert <falk@duebbert.com>
Date2018-04-26 11:48 +0200
Message-ID<pbs78h$ca5$1@news.albasani.net>
In reply to#243216
Am 24.04.18 um 20:35 schrieb Scherer Ralf:
> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?

Wenn es diskretisiert sein darf aber präzise sein muss, wären smd-Relais 
und Widerstände mein Ansatz.

Falk D.

[toc] | [prev] | [next] | [standalone]

#243276

FromHans-Peter Diettrich <DrDiettrich1@aol.com>
Date2018-04-26 12:39 +0200
Message-ID<fkdojfF9mbrU1@mid.individual.net>
In reply to#243273
Am 26.04.2018 um 11:48 schrieb Falk Dµebbert:
> Am 24.04.18 um 20:35 schrieb Scherer Ralf:
>> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?
> 
> Wenn es diskretisiert sein darf aber präzise sein muss, wären smd-Relais 
> und Widerstände mein Ansatz.

So funktionieren ja die digitalen Potis, nur mit Analogschaltern statt 
Relais. Und das dann eben auf einem Chip.

DoDi

[toc] | [prev] | [next] | [standalone]

#243283

FromScherer Ralf <RS.2007@gmx.de>
Date2018-04-26 21:27 +0200
Message-ID<fkenhjFglq9U1@mid.individual.net>
In reply to#243273
On 26/04/18 11:48, Falk Dµebbert wrote:
> Am 24.04.18 um 20:35 schrieb Scherer Ralf:
>> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?
> Wenn es diskretisiert sein darf aber präzise sein muss, wären smd-Relais 
> und Widerstände mein Ansatz.

So ein Teil habe ich hier. ATMega64 (OK, total oversize), 16 schnucklige 
Relais, 16 Widerstände.
IN PARALLELSCHALTUNG!!!

Und das Teil hat den gigantischen Vorteil:
1. Galvanisch getrennt
2. Es kann nur das tun was an Rs da ist,keine OP schwing, keine -U
3. Durch die parallel Schaltung addieren sich nicht die Kontakt-
    widerstände der Relais

Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine 
lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich 
nehmen? Die Sprünge sind mir erst mal "Wurscht"
Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen" 
PC berechnet?
Ich nehme (fast) alles C,C++,Perl,Python, egal,

Und wenn das als PM an Dich geht dann entschuldige bitte, ich versuche 
gerade meinen NewsAcount zu managen (Thunderbir, leafnode, inn...)
keine Ahnung wie.

Danke!
Ralf S.

[toc] | [prev] | [next] | [standalone]

#243284

FromGerrit Heitsch <gerrit@laosinh.s.bawue.de>
Date2018-04-26 21:32 +0200
Message-ID<pbt9gl$ih8$1@news.bawue.net>
In reply to#243283
On 04/26/2018 09:27 PM, Scherer Ralf wrote:
> On 26/04/18 11:48, Falk Dµebbert wrote:
>> Am 24.04.18 um 20:35 schrieb Scherer Ralf:
>>> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?
>> Wenn es diskretisiert sein darf aber präzise sein muss, wären 
>> smd-Relais und Widerstände mein Ansatz.
> 
> So ein Teil habe ich hier. ATMega64 (OK, total oversize), 16 schnucklige 
> Relais, 16 Widerstände.
> IN PARALLELSCHALTUNG!!!
> 
> Und das Teil hat den gigantischen Vorteil:
> 1. Galvanisch getrennt
> 2. Es kann nur das tun was an Rs da ist,keine OP schwing, keine -U
> 3. Durch die parallel Schaltung addieren sich nicht die Kontakt-
>     widerstände der Relais
> 
> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine 
> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich 
> nehmen? Die Sprünge sind mir erst mal "Wurscht"

Wenn du mit Parallelschaltung arbeitest und der höchste Widerstand 100 
kOhm sein soll, dann ist schonmal ein Widerstand bekannt, er muss eben 
diese 100 kOhm haben. Du musst also keine 16 berechnen sondern nur 15.

  Gerrit

[toc] | [prev] | [next] | [standalone]

#243285

FromOlaf Schultz <o.schultz@enhydralutris.de>
Date2018-04-26 21:39 +0200
Message-ID<fkeo7cFgq1tU1@mid.individual.net>
In reply to#243283
On 04/26/2018 09:27 PM, Scherer Ralf wrote:
> On 26/04/18 11:48, Falk Dµebbert wrote:
>> Am 24.04.18 um 20:35 schrieb Scherer Ralf:
>>> Gibt eine Schaltung mit OP(s) + DA-Wandler, die das linear macht?
>> Wenn es diskretisiert sein darf aber präzise sein muss, wären
>> smd-Relais und Widerstände mein Ansatz.
> 
> So ein Teil habe ich hier. ATMega64 (OK, total oversize), 16 schnucklige
> Relais, 16 Widerstände.
> IN PARALLELSCHALTUNG!!!
> 
> Und das Teil hat den gigantischen Vorteil:
> 1. Galvanisch getrennt
> 2. Es kann nur das tun was an Rs da ist,keine OP schwing, keine -U
> 3. Durch die parallel Schaltung addieren sich nicht die Kontakt-
>    widerstände der Relais
> 
> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine
> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich
> nehmen? Die Sprünge sind mir erst mal "Wurscht"
> Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen"
> PC berechnet?
> Ich nehme (fast) alles C,C++,Perl,Python, egal,


Also, die Eriksson  LTN1502 hier hat
10+20+20+50+100+200+200+500+1k+2k+2k+5k+10k+20k+20k+50k in Serie schaltbar

Wobei ein Abbgriff/Teilung zwischen 500+1k möglich ist

Olaf, alleine das Gehäuse und die Haptik der Schalter sind eine Wonne.

[toc] | [prev] | [next] | [standalone]

#243318

FromEdzard Egberts <news@edzeg.net>
Date2018-04-28 15:56 +0200
Message-ID<pc1ui4$nki$1@gwaiyur.mb-net.net>
In reply to#243283
Scherer Ralf schrieb:
> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine
> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich
> nehmen? Die Sprünge sind mir erst mal "Wurscht"
> Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen"
> PC berechnet?
> Ich nehme (fast) alles C,C++,Perl,Python, egal,

Hehe, so eine Brute-Force-Aufgabe hat mich schon gereizt, bin ja mal
gespannt wie lange das bei Dir läuft. Da ich die Linearität über ein
C++-set bestimme, also sortiere und doppelte Werte entferne, muss für
das Ergebnis noch eine Wertetabelle erstellt werden, welche Abfolge von
Schalterstellungen die lineare Kurve ergibt. Also für kleinere Vorgaben
(weniger Widerstände und Schalter) terminiert das Programm, das müsste
also klappen.

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

#include <set>
#include <vector>
#include <iostream>
	using std::cout;
	using std::endl;
#include <math.h>


int main()
{
	// Für die Parallelschaltung von 16 Widerständen per Relais soll für den
	// Bereich von 80R..100k die Kombination von Widerständen ermittelt werden,
	// die die linearste Verteilung von Widerstandswerten ergibt.

	// Der obere Werte 100k wird als 17ter Widerstand angenommen.
	//
	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 R_Min= 80;
	double R_Max= 100000;
	unsigned N_Schalter= 16;

	cout << "Resistors to check" << endl;
	std::vector< double > R_All;
	for (unsigned d= 2; d < 6; ++d)				// Dekade der Widerstandswerte
		for (unsigned i= 0; E12_Reihe[i]; ++i)	// Werte der Widerstandsreihe
		{	// Widerstandswerte von 100R bis 820k eintragen
			double R= E12_Reihe[i]*pow(10, d);
			R_All.push_back(R);
			cout << R << endl;
		}

	std::vector< unsigned > Widerstand(N_Schalter, 0);	// Für jeden
Schalter ein Widerstandszähler
	// Zum Durchprobieren aller Widerstandskombinationen wird für jede
Schalterposition
	// ein Index in den R_All-Vektor hochgezählt
	double Best_Match= -1.0;
	std::vector< double > Best_R(N_Schalter, 0);
	while (Widerstand[N_Schalter -1] < R_All.size())
	{	// Probieren, bis die letzte Stelle zum letzten Widerstand gezählt ist
		std::set< double > Current_R;	// Set für aktuelle Ergebnisse
		unsigned s= 0;
		for (; s < pow(2, N_Schalter); ++s)
		{	// Zähler für alle Schalterkombinationen von 0 bis 0xFFFF
			//	R= 1/(1/R1 + 1/R2 + 1/R3 ... + 1/Rn)
			double Leitwert= 0;
			unsigned Bit= 1;
			for (unsigned Pos= 0; Pos < N_Schalter; ++Pos)		// Für die Positionen
von 0..16
			{	// Für alle Schalter von 0..N_Schalter
				if (s & Bit) Leitwert+= 1.0/R_All[Widerstand[Pos]];
					// Wenn der Schalter geschlossen ist (1) Leitwert des aktuellen
Widerstands aufaddieren
				Bit <<= 1;	// Nächstes Bit prüfen
			}

			double R= 1/(1.0/100000 + Leitwert);
				// Aus aufsummierten Leitwert abschließend Widerstand bestimmen,
dabei 100k parallel schalten

			if (R >= R_Min && R <= R_Max) Current_R.insert(R);	// Gültigen Wert
in die Linearitätsprüfung
		}

		if (s == pow(2, N_Schalter))
		{	// Schleife ist komplett durchgelaufen, Linearität des Ergebnisses
prüfen
			double Step= (R_Max - R_Min)/Current_R.size();
			double R_Lin= R_Min;
			double Match= 0;
			for (std::set< double >::const_iterator it= Current_R.begin(); it!=
Current_R.end(); ++it)
			{
				Match+= fabs(*it - R_Lin);
				R_Lin+= Step;
			}
			Match/= Current_R.size();
			if (Match < Best_Match || Best_Match== -1)
			{	// Bisher geringste Abweichung von der Linearität gefunden
				Best_Match= Match;
				cout << endl << "Better Match found " << Best_Match << " for" << endl;
				for (unsigned i= 0; i< N_Schalter; ++i)
				{
					Best_R[i]= R_All[Widerstand[i]];
					cout << i << ' ' << R_All[Widerstand[i]] << endl;
				}
			}
		}

		// Widerstandskombinationen hochzählen
		bool Show_State= false;	// Anzeigen, dass noch etwas läuft
		for (unsigned r= 0; r < N_Schalter; ++r)
			if (++Widerstand[r] == R_All.size() && r!= N_Schalter -1)
			{
				Widerstand[r]= 0;
				if (r== 1) Show_State= true;
			}
			else break;
		if (Show_State)
		{
			for (unsigned r= 0; r < N_Schalter; ++r) cout << Widerstand[r] << ' ';
			cout << endl;
		}
	}
	cout << "Best Match found for:" << endl;
	for (unsigned i= 0; i< Best_R.size(); ++i) cout << i << ' ' <<
Best_R[i] << endl;
}

[toc] | [prev] | [next] | [standalone]

#243331

FromEdzard Egberts <news@edzeg.net>
Date2018-04-28 19:59 +0200
Message-ID<pc2cqn$tj8$1@gwaiyur.mb-net.net>
In reply to#243318
Edzard Egberts schrieb:
> Scherer Ralf schrieb:
>> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine
>> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich
>> nehmen? Die Sprünge sind mir erst mal "Wurscht"
>> Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen"
>> PC berechnet?
>> Ich nehme (fast) alles C,C++,Perl,Python, egal,

Noch eine verbesserte Version, die auch äquivalente Kombinationen
ausgibt und zwar in eine Datei, nicht mehr nur auf die Konsole.

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

#include <set>
#include <vector>
#include <iostream>
	using std::cout;
	using std::endl;
#include <fstream>
	using std::fstream;
	using std::ios_base;
#include <math.h>


int main()
{
	// Für die Parallelschaltung von 16 Widerständen per Relais soll für den
	// Bereich von 80R..100k die Kombination von Widerständen ermittelt werden,
	// die die linearste Verteilung von Widerstandswerten ergibt.

	// Der obere Werte 100k wird als 17ter Widerstand angenommen.
	//
	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 R_Min= 80;
	double R_Max= 100000;
	unsigned N_Schalter= 16;

	cout << "Resistors to check" << endl;
	std::vector< double > R_All;
	for (unsigned d= 2; d < 6; ++d)				// Dekade der Widerstandswerte
		for (unsigned i= 0; E12_Reihe[i]; ++i)	// Werte der Widerstandsreihe
		{	// Widerstandswerte von 100R bis 820k eintragen
			double R= E12_Reihe[i]*pow(10, d);
			R_All.push_back(R);
			cout << R << endl;
		}

	std::vector< unsigned > Widerstand(N_Schalter, 0);	// Für jeden
Schalter ein Widerstandszähler
	// Zum Durchprobieren aller Widerstandskombinationen wird für jede
Schalterposition
	// ein Index in den R_All-Vektor hochgezählt
	double Best_Match= -1.0;
	while (Widerstand[N_Schalter -1] < R_All.size())
	{	// Probieren, bis die letzte Stelle zum letzten Widerstand gezählt ist
		std::set< double > Current_R;	// Set für aktuelle Ergebnisse
		unsigned s= 0;
		for (; s < pow(2, N_Schalter); ++s)
		{	// Zähler für alle Schalterkombinationen von 0 bis 0xFFFF
			//	R= 1/(1/R1 + 1/R2 + 1/R3 ... + 1/Rn)
			double Leitwert= 0;
			unsigned Bit= 1;
			for (unsigned Pos= 0; Pos < N_Schalter; ++Pos)		// Für die Positionen
von 0..16
			{	// Für alle Schalter von 0..N_Schalter
				if (s & Bit) Leitwert+= 1.0/R_All[Widerstand[Pos]];
					// Wenn der Schalter geschlossen ist (1) Leitwert des aktuellen
Widerstands aufaddieren
				Bit <<= 1;	// Nächstes Bit prüfen
			}

			double R= 1/(1.0/100000 + Leitwert);
				// Aus aufsummierten Leitwert abschließend Widerstand bestimmen,
dabei 100k parallel schalten

			if (R >= R_Min && R <= R_Max) Current_R.insert(R);	// Gültigen Wert
in die Linearitätsprüfung
		}

		if (s == pow(2, N_Schalter))
		{	// Schleife ist komplett durchgelaufen, Linearität des Ergebnisses
prüfen
			double Step= (R_Max - R_Min)/Current_R.size();
			double R_Lin= R_Min;
			double Match= 0;
			for (std::set< double >::const_iterator it= Current_R.begin(); it!=
Current_R.end(); ++it)
			{	// Aufsteigende Werte des Sets mit äquivalentem linearen Wert
vergleichen
				Match+= fabs(*it - R_Lin);	//	Abweichungen aufaddieren
				R_Lin+= Step;	// Vergleichswiderstand aufaddieren
			}
			Match/= Current_R.size();
			if (Match <= Best_Match || Best_Match== -1)
			{	// Bisher geringste Abweichung von der Linearität gefunden
				Best_Match= Match;
				fstream Out("Matches.txt", ios_base::out | ios_base::app);
				Out << Best_Match << ' ' << Current_R.size() << ' ';
				cout << "Better Match found " << Best_Match << " steps " <<
Current_R.size() << endl;
				for (unsigned i= 0; i< N_Schalter; ++i) Out <<  R_All[Widerstand[i]]
<< ' ';
				Out << endl;
				Out.close();
			}
		}

		// Widerstandskombinationen hochzählen
		bool Show_State= false;	// Anzeigen, dass noch etwas läuft
		for (unsigned r= 0; r < N_Schalter; ++r)
			if (++Widerstand[r] == R_All.size() && r!= N_Schalter -1)
			{
				Widerstand[r]= 0;
				if (r== 1) Show_State= true;
			}
			else break;
		if (Show_State)
		{
			for (unsigned r= 0; r < N_Schalter; ++r) cout << Widerstand[r] << ' ';
			cout << endl;
		}
	}
}

[toc] | [prev] | [next] | [standalone]

#243372

FromScherer Ralf <RS.2007@gmx.de>
Date2018-05-01 18:24 +0200
Message-ID<fkriltFc28uU1@mid.individual.net>
In reply to#243318
On 28/04/18 15:56, Edzard Egberts wrote:
> Scherer Ralf schrieb:
>> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine
>> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich
>> nehmen? Die Sprünge sind mir erst mal "Wurscht"
>> Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen"
>> PC berechnet?
>> Ich nehme (fast) alles C,C++,Perl,Python, egal,
> 
> Hehe, so eine Brute-Force-Aufgabe hat mich schon gereizt, bin ja mal
> gespannt wie lange das bei Dir läuft. Da ich die Linearität über ein
> C++-set bestimme, also sortiere und doppelte Werte entferne, muss für
> das Ergebnis noch eine Wertetabelle erstellt werden, welche Abfolge von
> Schalterstellungen die lineare Kurve ergibt. Also für kleinere Vorgaben
> (weniger Widerstände und Schalter) terminiert das Programm, das müsste
> also klappen.

Wow, mal ganz davon abgesehen, dass mir (noch) nicht klar ist, wie du 
die Linearität prüfst, erst mal Hut ab!
Am Freitag habe ich 10Std. Zugfahrt vor mir, ich hoffe, das ich am Ende 
verstehe was Du programmiert hast ;) evtl. ist dann auch mein PC fertig 
mit der Berechnung. Als sich am Bildschirm nichts mehr tat dachte ich 
schon "Das ging aber flott", Brüller, da fing es erst an interessant zu 
werden.
Was mich daran am meisten irritiert, ist, das es in der Schweiz eine FA. 
gibt die so ein Teil verkauft. 23-24! Widerstände parallel, und das 
nicht per Drehschalter sondern per LCD-Display einstellbar. Wie machen 
die das? Eine Tabelle ist zu groß, berechnen dauert zu lang?

Du sagtest "Brute-Force-Aufgabe" und hast recht, zumindest mit meinen 
Mathe-Kenntnissen ist mir keine Methode bekannt diese Aufgaben anders
zu lösen.

Einen schönen 1. Mai
Ralf

[toc] | [prev] | [next] | [standalone]

#243386

FromEdzard Egberts <news@edzeg.net>
Date2018-05-01 19:52 +0200
Message-ID<pca9g6$hqu$1@gwaiyur.mb-net.net>
In reply to#243372
Scherer Ralf schrieb:
> On 28/04/18 15:56, Edzard Egberts wrote:
>> Scherer Ralf schrieb:
>>> Aber! Wenn ich jetzt frage: Ich möchte von 80 Ohm bis 100kOhm eine
>>> lineare! Reihe von Werten bekommen, welche 16 Widerstände muss ich
>>> nehmen? Die Sprünge sind mir erst mal "Wurscht"
>>> Wie würde die Formel lauten die das in T < 3 Tagen, mit einem "normalen"
>>> PC berechnet?
>>> Ich nehme (fast) alles C,C++,Perl,Python, egal,
>>
>> Hehe, so eine Brute-Force-Aufgabe hat mich schon gereizt, bin ja mal
>> gespannt wie lange das bei Dir läuft. Da ich die Linearität über ein
>> C++-set bestimme, also sortiere und doppelte Werte entferne, muss für
>> das Ergebnis noch eine Wertetabelle erstellt werden, welche Abfolge von
>> Schalterstellungen die lineare Kurve ergibt. Also für kleinere Vorgaben
>> (weniger Widerstände und Schalter) terminiert das Programm, das müsste
>> also klappen.
> 
> Wow, mal ganz davon abgesehen, dass mir (noch) nicht klar ist, wie du
> die Linearität prüfst, erst mal Hut ab!

Die Prüfung taugt auch nichts. Ich habe mir die Ergebnisse von vier
Schaltern (das geht flott ;o) angesehen und musste feststellen, dass
"Linearität" nicht reicht, weil z.B. dazu nicht der Wert von ca. 80 Ohm
vorhanden sein muss. Außerdem ergaben sich gruppierte Werte, also ein
ähnlicher Wert mehrfach wiederholt.

Von der Idee her vergleicht der Test die Werte des Sets mit einer
entsprechenden Gerade, je geringer die Abstände Werte <-> Gerade sind,
desto kleiner, also besser, wird der Matchwert. Die Größe des sets gibt
die Anzahl der Widerstandswerte an, die über die Kombinationen erreicht
werden. Man sollte noch den Abstand der Werte untereinander in den
Vergleich mit aufnehmen.

> Am Freitag habe ich 10Std. Zugfahrt vor mir, ich hoffe, das ich am Ende
> verstehe was Du programmiert hast ;)

Das ist wirklich einfach, alle Widerstandkombinationen mit allen
Schalterstellungen durchprobiert. Allerdings habe ich mir einen Stapel
geschachtelter Schleifen gespart, indem ich ein großes "Register" hochzähle.

> evtl. ist dann auch mein PC fertig
> mit der Berechnung. Als sich am Bildschirm nichts mehr tat dachte ich
> schon "Das ging aber flott", Brüller, da fing es erst an interessant zu
> werden.

Na ja, im Moment ist offensichtlich, dass das deutlich länger als drei
Tage dauern würde. Man kann auf jeden Fall schon mal alle
Widerstandskombinationen ausschließen, bei denen "alle ein" deutlich
größer als 80 Ohm ist, damit spart man sich eine komplette
"Schalterschleife". Ansonsten würde ich mit kleineren Schalterzahlen
experimentieren (4 geht richtig schnell, 8 wird langwierig) und mir die
Ergebnisse ansehen, vielleicht fällt noch etwas auf. Die Anzahl der
Widerstände zu begrenzen, bringt natürlich auch einiges, z.B. die
E6-Reihe. Bin mir sowieso nicht sicher, ob nicht noch die nächste Dekade
dabei sein müsste, 820k ist noch arg niedrig, ergibt als oberen Wert der
Reihe 90k.

> Was mich daran am meisten irritiert, ist, das es in der Schweiz eine FA.
> gibt die so ein Teil verkauft. 23-24! Widerstände parallel, und das
> nicht per Drehschalter sondern per LCD-Display einstellbar. Wie machen
> die das? Eine Tabelle ist zu groß, berechnen dauert zu lang?

Wenn die Widerstände gegeben sind, dauert die Berechnung gar nicht so
lange (innere "Schalterschleife"). Was hier so lange dauert, ist das
Ausprobieren der Widerstandskombinationen.

> Du sagtest "Brute-Force-Aufgabe" und hast recht, zumindest mit meinen
> Mathe-Kenntnissen ist mir keine Methode bekannt diese Aufgaben anders
> zu lösen.

Um das in einem machbaren Zeitraum zu lösen, muss man noch ein paar
Bedingungen einbringen und die Widerstandskombinationen deutlich
beschränken. In jedem Fall erst einmal mit wenigen Schaltern testen, bis
ein vernünftiges Ergebnis heraus kommt. Der letzte Test sieht nicht so
toll aus, allerdings sollte man sich auch mehr als nur die letzte
Kombination ansehen, das habe ich nicht weiter verfolgt.

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

#include <set>
#include <vector>
#include <limits>
#include <iostream>
	using std::cout;
	using std::endl;
#include <fstream>
	using std::fstream;
	using std::ios_base;
#include <math.h>


int main()
{
	// Für die Parallelschaltung von 16 Widerständen per Relais soll für den
	// Bereich von 80R..100k die Kombination von Widerständen ermittelt werden,
	// die die linearste Verteilung von Widerstandswerten ergibt.

	// Der obere Werte 100k wird als 17ter Widerstand angenommen.
	//
	double E6_Reihe[]=
	{
		1.0, 1.5, 2.2, 3.3, 4.7, 6.8, 0.0
	};
	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 R_Min= 80;
	double R_Max= 100000;
	unsigned N_Schalter= 4;	// 16 TODO

	cout << "Resistors to check" << endl;
	std::vector< double > R_All;
	for (unsigned d= 2; d < 6; ++d)				// Dekade der Widerstandswerte
		for (unsigned i= 0; E12_Reihe[i]; ++i)	// Werte der Widerstandsreihe
		{	// Widerstandswerte von 100R bis 820k eintragen
			double R= E12_Reihe[i]*pow(10, d);
			R_All.push_back(R);
			cout << R << endl;
		}

	std::vector< unsigned > Widerstand(N_Schalter, 0);	// Für jeden
Schalter ein Widerstandszähler
	std::set< double > Current_R;	// Set für aktuelle Ergebnisse
	std::vector< double > Best_R(N_Schalter);	// Jeweils letztes bestes
Ergebnis
	// Zum Durchprobieren aller Widerstandskombinationen wird für jede
Schalterposition
	// ein Index in den R_All-Vektor hochgezählt
	double Best_Match= std::numeric_limits< double >::max();	// Kleinere
Werte sind besser!
	double Best_Dist= Best_Match;
	unsigned Best_Steps= 0;
	unsigned s, Bit, Pos, i, r;
	double Leitwert, R, Step, R_Lin, Match, Lin_Min, Mid_Dist;
		// Variablen vordefinieren beschleunigt die Schleifen
	while (Widerstand[N_Schalter -1] < R_All.size())
	{	// Probieren, bis die letzte Stelle zum letzten Widerstand gezählt ist
		// Zuerst R_Min der aktuellen Kombination bestimmen, sollte
gewünschten R_Min einhalten
		Leitwert= 0;
		Bit= 1;
		for ( Pos= 0; Pos < N_Schalter; ++Pos) Leitwert+=
1.0/R_All[Widerstand[Pos]];
			// Für alle Widerstände von 0..N_Schalter den Leitwert bestimmen
		R= 1/(1.0/100000 + Leitwert);

		if (R < R_Min + 5)
		{	// Kleinster Wert unterschreitet gewünschten R-Min, also Kombination
weiter prüfen:
			Current_R.clear();
			s= 0;
			for (; s < pow(2, N_Schalter); ++s)
			{	// Zähler für alle Schalterkombinationen von 0 bis 0xFFFF
				//	R= 1/(1/R1 + 1/R2 + 1/R3 ... + 1/Rn)
				Leitwert= 0;
				Bit= 1;
				for ( Pos= 0; Pos < N_Schalter; ++Pos)
				{	// Für alle Schalter von 0..N_Schalter
					if (s & Bit) Leitwert+= 1.0/R_All[Widerstand[Pos]];
						// Wenn der Schalter geschlossen ist (1) Leitwert des aktuellen
Widerstands aufaddieren
					Bit <<= 1;	// Nächstes Bit prüfen
				}

				R= 1/(1.0/100000 + Leitwert);
					// Aus aufsummierten Leitwert abschließend Widerstand bestimmen,
dabei 100k parallel schalten

				if (R >= R_Min && R <= R_Max) Current_R.insert(R);	// Gültigen Wert
in die Linearitätsprüfung
			}

			if (s == pow(2, N_Schalter))
			{	// Schleife ist komplett durchgelaufen, Linearität des Ergebnisses
prüfen
				Step= (R_Max - R_Min)/Current_R.size();
				R_Lin= R_Min;
				Lin_Min= R_Max;	// Start des linearen Widerstands
				Match= 0;
				Mid_Dist= 0;
				std::set< double >::const_iterator itl= Current_R.begin();
				for (std::set< double >::const_iterator it= Current_R.begin(); it!=
Current_R.end(); ++it)
				{	// Aufsteigende Werte des Sets mit äquivalentem linearen Wert
vergleichen
					if (*it < Lin_Min) Lin_Min= *it;
					Match+= fabs(*it - R_Lin);	//	Abweichungen aufaddieren
					R_Lin+= Step;		// Linearen Vergleichswiderstand aufaddieren
					if (it!= Current_R.begin()) Mid_Dist+= fabs(Step - fabs(*it - *itl));
						// Abweichung der aktuellen Schrittweite von der idealen
Schrittweite aufaddieren
					itl= it;
				}
				Mid_Dist/= Current_R.size() -1;	// Mittelwert der Abstände, sollte
möglichst groß sien
				Match/= Current_R.size();	// Mittlere Abweichung bestimmen
				if (Match <= Best_Match		// Bessere oder gleiche Lineariät
				 || Mid_Dist <= Best_Dist	// Gleich
				 || Best_Steps < Current_R.size())
				{	// Bisher geringste Abweichung von der Linearität gefunden
					if (Match < Best_Match) Best_Match= Match;
					if (Mid_Dist < Best_Dist) Best_Dist= Mid_Dist;
					if (Current_R.size() > Best_Steps) Best_Steps= Current_R.size();
					fstream Out("matches.txt", ios_base::out | ios_base::app);
					Out << Best_Match << ' ' << Best_Dist << ' ' << Best_Steps << ' ';
					cout << "Better match found " << Best_Match << ' ' << Best_Dist <<
" steps " << Best_Steps << endl;
					for (i= 0; i< N_Schalter; ++i)
					{
						Out <<  R_All[Widerstand[i]] << ' ';
						Best_R[i]= R_All[Widerstand[i]];
					}
					Out << endl;
					Out.close();
				}
			}
		}

		// Widerstandskombinationen hochzählen
		bool Show_State= false;	// Anzeigen, dass noch etwas läuft
		for (r= 0; r < N_Schalter; ++r)
			if (++Widerstand[r] == R_All.size() && r!= N_Schalter -1)
			{
				Widerstand[r]= 0;
				if (r== 1) Show_State= true;
			}
			else break;
		if (Show_State)
		{
			for (r= 0; r < N_Schalter; ++r) cout << Widerstand[r] << ' ';
			cout << endl;
		}
	}

	cout << "Best R" << endl;
	for (i= 0; i< Best_R.size(); ++i) cout << Best_R[i] << ' ';
	cout << endl;
	Current_R.clear();
	s= 0;
	for (; s < pow(2, N_Schalter); ++s)
	{	// Zähler für alle Schalterkombinationen von 0 bis 0xFFFF
		//	R= 1/(1/R1 + 1/R2 + 1/R3 ... + 1/Rn)
		Leitwert= 0;
		Bit= 1;
		for ( Pos= 0; Pos < N_Schalter; ++Pos)
		{	// Für alle Schalter von 0..N_Schalter
			if (s & Bit) Leitwert+= 1.0/Best_R[Pos];
				// Wenn der Schalter geschlossen ist (1) Leitwert des aktuellen
Widerstands aufaddieren
			Bit <<= 1;	// Nächstes Bit prüfen
		}

		R= 1/(1.0/100000 + Leitwert);
			// Aus aufsummierten Leitwert abschließend Widerstand bestimmen,
dabei 100k parallel schalten

		if (R >= R_Min && R <= R_Max) Current_R.insert(R);	// Gültigen Wert in
die Linearitätsprüfung
	}
	cout << "Widerstandsverlauf" << endl;
	for (std::set< double >::const_iterator it= Current_R.begin(); it!=
Current_R.end(); ++it)
		cout << *it << endl;
}

[toc] | [prev] | [next] | [standalone]

Page 1 of 4  [1] 2 3 4  Next page →

Back to top | Article view | de.sci.electronics

csiph-web