Motståndsoptimerare

[pagge]

Näe, jag menar att man bara skall ta med kombinationer som ger 1 till 10Ohm totalt, inte att man endast får använda motstånd av värdena 1-10. Använd t.ex. 0.01 till 1k, dvs 100 ggr lägre till 100 ggr högre. Då får man med de flesta vettiga kombinationer.

btw. tror jag att jag hittat ett fel, denna rad ser inte riktigt rätt ut.
1.020k 1k 7k (parallellt)

paralellformeln är:
R1 paralellt med R2 = R1*R2/(R1+R2)

[cykze]

Jag trodde jag plockade bort den där listan igår. Upptäckte några fel (både i programmet och tankeverksamheten ), och tänkte fortsätta idag.

Jag hade avrundat motståndsvärdena till heltal vilket gjorde att uträkningarna såg ut att vara felaktiga.

Nu är jag osäker på om jag vet vad du menar. Chansar på att det är så här (bortse från den konstiga formateringen).

[pagge]

Precis så var det jag tänkte mig, vill jag t.ex. ha ett 94k motstånd nu så kollar jag efter 9.4 och finner 4.7+4.7. Sen lägger jag på fyra nollor och får att 94000 = 47000+47000.

Den fungerar ju för kondensatorer också om man bara byter plats på orden "paralellt" och "seriellt" kom jag just på .

[peter555]

Hej

Det var en trevlig lista, kan du inte göra en körning med E24 motstånd också.

Peter

[cykze]

Jo, visst.

E24-serien

Tänkte att jag skulle formatera listorna lite snyggare någon gång.

edit: Gjorde om listan där ett värde som precis låg på decimalgränsen lades till.

[peter555]

Tackar !

[baron3d]

Tack så mycket. Verkeligen efterlängtat

[Micket]

Lite haskell!
Den är jävligt långsamt dock

Kod: Markera allt

import List

data Expr
	= Op BinOp Expr Expr
	| Res Double
	deriving (Show, Eq, Ord)

data BinOp
	= Ser
	| Par
	deriving (Show, Eq, Ord)

ohm = [10, 12, 15, 21, 27, 33, 39, 47, 56, 68, 82]

combine max res = pickBest res $ map combine2 [1..max]

pickBest res e = doPrint $ (\(_,y,x)->(y,x)) $ head $ sort [(abs(fst x -res),fst x,snd x)|x<-(concat e)]

combine2 1 = zip ohm $ map Res ohm
combine2 x = clearCopies $ sort ([(v2 y (fst x),Op Par (Res y) (snd x))|y<-ohm,x<-z]++
			         [(v1 y (fst x),Op Ser (Res y) (snd x))|y<-ohm,x<-z])
	where 
	z = combine2 (x-1)
	v1 y x = x+y
	v2 y x = x*y/(x+y)
-- For sorted lists
clearCopies [] = []
clearCopies (x:xs) = x:(clearCopies $ dropWhile (\(y,_)->y==fst x) xs) -- Exact
--clearCopies (x:xs) = x:(clearCopies $ dropWhile (\(y,_)->y-(fst x)<(0.00001*fst x)) xs) -- Approximative

doPrint (x,y) = putStrLn $ (printer y)++" = "++show x 

printer :: Expr -> String
printer (Res e1) = show e1
printer (Op Ser e1 e2) = "("++printer e1++")+("++printer e2++")"
printer (Op Par e1 e2) = "("++printer e1++")|("++printer e2++")"

Exempelkörning

Kod: Markera allt

*Main> combine 2 15.1234567
15.0 = 15.0
*Main> combine 3 15.1234567
(21.0)|((15.0)+(39.0)) = 15.12
*Main> combine 4 15.1234567
(56.0)|((12.0)+((10.0)|(68.0))) = 15.122994652406414
*Main> combine 5 15.1234567
(27.0)|((21.0)+((15.0)|((56.0)+(68.0)))) = 15.123417721518987

Med icke förstörande rensning av kombinationer så pallar den max 5 motstånd med dessa att utgå från
[10, 12, 15, 21, 27, 33, 39, 47, 56, 68, 82]

(Använde | för parallellkoppling)

[cykze]

Lite Python. Listan genereras lite lagom snabbt (ca 1.5 sekund).

Koden innehåller tester med lite olika metoder, så den kan vara lite rörig. Tips på förbättringar i koden är som vanligt välkommna.

Kod: Markera allt

#!/usr/bin/env python
#
# Per Jonsson, 2006
#

e12_base = (10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82)
e24_base = (10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82, 91)

def gen_e_serie(min, max, base):
	zeros = 0
	ret = []

	# Soker efter ratt 10-bas att borja fran
	while base[0]*10.0**zeros > min:
		zeros -= 1

	while 1:
		for nr in base:
			value = nr * 10**zeros

			if value > max:
				return ret
			elif value >= min:
				ret.append(value)

		zeros += 1

class resistor_comb:
	def __init__(self, r1, r2, op, desc=''):
		self.r1 = r1
		self.r2 = r2
		self.desc = desc
		
		self.res = op(r1, r2)

	def __repr__(self):
		tmp_desc = self.desc
		if tmp_desc != '':
			tmp_desc = '  (%s)' % tmp_desc

		# Snabb fulfix for att bli av med sista nollan
		r2 = '%8.3f' % self.r2
		assert r2[-1] == '0'
		r2 = '%8.2f' % self.r2
		
		return '%8.3f %8.3f %s%s' % (self.res, self.r1, r2, tmp_desc)
		
	def __cmp__(self, b):
		if self.res > b.res:
			return 1
		else:
			return -1

serie = gen_e_serie(0.01, 1000, e24_base)

results = []
#for r1 in serie:
#	for r2 in serie:
#		results.append( resistor_comb(r1, r2) )

for i in range(0, len(serie)):
	for j in range(i, len(serie)):
		results.append( resistor_comb(serie[i], serie[j], lambda r1,r2 : r1+r2, 'seriellt') )
		results.append( resistor_comb(serie[i], serie[j], lambda r1,r2 : (float(r1)*r2)/(r1+r2), 'parallellt') )

results.sort()

#print '    R1/R2       R1       R2'
#print '(R1+R2)/R1      R1       R2'
print '   R_tot       R1       R2'
print '---------------------------------------'

for comb in results:
	#if comb.r1 != comb.r2:

	# De konstiga decimaltalen ar till for att aven fa med
	# tal som t ex 0.9999 och 10.0001
	if comb.res >= 0.99999 and comb.res <= 10.00001:
		print comb

[JimmyAndersson]

Det här är ju en riktigt användbar tråd. Kan inte någon lägga in en sammanfattning i Wikin eller klistra tråden på lämpligt ställe?

Det tog ett tag innan jag hittade tråden. Visste bara att den fanns i Allmänt-delen och hoppades att den hette något med "motstånd"...


Behövde nyss 931Ω och 274Ω. Började först räkna med den vanliga formeln, men det tar ju ett tag innan man hittar motstånd som finns (i E12-serien). Den här tråden och programmet ResistorSelector gav en bra och snabb lösning.

931Ω = Parallellkoppla 10k och 15k.
274Ω = Parallellkoppla 330Ω och 1.5k.
Utmärkt!

[pagge]

Jag lånar den här gamla tråden igen och gör reklam för min lilla applet som också fixxar biffen

http://bart.sm.luth.se/~axeala-0/elek/r ... /main.html

Edit: Ny url

[HUGGBÄVERN]

Minns att elektor hade ett enkelt BASIC-program som plockade värden (E12-serien) och kombinerade ihop dem (serie/parallell) så man fick önskat notstånd. Programmet körde mot en maxavvikelse som man också fick ange och som sagt tog fram kombinationer som låg innanför denna.
Ska leta lite....

(Skulle man inte kunna slänga ihop något i excel??

[pagge]

Säkerligen skulle man kunna göra nåt i excel. Hade själv en variant i matlab ett tag. Problemet (för mig som flyttar runt bland många datorer) är att man måste installera det överallt. Jag gjorde det här lilla programmet för att kunna räkna motstånd var jag än sitter utan att behöva installera nåt (förvisso så länge JRE är installerat, men det brukar det vara)

Jag ska ta och koda i den där funktionen du sa, att man kan ange en minimum tolerans och så kollar programmet vilken serie man måste använda. Ska även lägga in att den kan använda tre motstånd. Detta är första beta versionen

[HUGGBÄVERN]

Nu ska vi se ... var det du som skrivit Java-äpplet?? Snyggt. Nåt sånt funkade Elektors BASIC-program.

Jag tror man kan göra mycket i Excel men man har aldrig tid, ork eller lust att sätta sig ned och börja grunna på saker.

[pagge]

Nu har jag vaxat äpplet lite så att säga
Jag la till så den testar använda tre motstånd. Mer än så behöver man nog aldrig så länge man bara har 1% motstånd. Det blev ingen minsta toleransinställning, det är ju rätt lätt att bara ta en bättre serie tills man får bra nog tolerans. Till och med e3 ger ju väldigt precisa värden har jag märkt om man använder tre motstånd.