Como obter qualquer resistência / capacitância usando componentes que você já possui !: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:34

Esta não é apenas mais uma calculadora de resistência equivalente em série / paralelo! Este programa calcula como combinar resistores / capacitores que você tem atualmente para atingir um valor de resistência / capacitância alvo que você precisa.

Você já precisou de um resistor ou capacitor específico que não tem ou que não existe? Não tenha medo! Você provavelmente pode fazer essa resistência específica ou valor de capacitância usando componentes que você já tem. Em vez de resolver um grande problema de otimização multivariável com milhões de combinações diferentes, use este programa!

Basta selecionar o resistor ou capacitor, inserir o valor alvo, inserir o número máximo de componentes que você gostaria de usar, inserir uma lista dos valores dos componentes que você possui e clicar em calcular! O programa mostrará quais componentes usar e como conectá-los para atingir o valor desejado.

Para experimentar a calculadora, visite este aplicativo da web.

Para visualizar o código-fonte, visite este repositório Github.

Por favor, deixe-me saber se você tem alguma sugestão para melhorar ainda mais a usabilidade desta ferramenta de design!

Etapa 1: Plano de fundo

Este aplicativo da web foi desenvolvido por necessidade. Existem muitos circuitos diferentes que construo que exigem um resistor ou capacitor muito específico. Muitas vezes, não tenho um resistor ou capacitor com esse valor específico. Às vezes, eles nem mesmo fazem um componente com esse valor exclusivo! Em vez de desistir ou se contentar com algo que está aquém do ideal, decidi escrever um programa para examinar todas as combinações possíveis de resistores (todos os valores possíveis e se eles estão em série ou em paralelo) e retornar a melhor combinação.

Ao projetar o circuito do meu órgão como parte do meu Projeto Instrutível da Batalha das Bandas, tive que tentar calcular manualmente a melhor combinação de capacitores para atingir uma frequência específica. Esse processo era incrivelmente tedioso e, eventualmente, desisti e fui com combinações de capacitores que produziam qualquer quantidade de frequência audível. Agora, com este aplicativo da web, posso projetar meu órgão para uma frequência específica e sintonizá-lo com as notas de um teclado! A equação abaixo é usada para calcular a frequência específica e é discutida no outro projeto Instructables.

f = 1 / (0,693 × C × (R1 + 2 × R2))

Usando esta equação onde R1 = 100 kOhm e R2 = 10 kOhm, calculei que um capacitor 27,33 nF produzirá uma nota A4 (frequência 440 Hz). Usando meu programa, fui capaz de calcular um valor de capacitância equivalente dentro de 0,001 nF (muito menos do que a tolerância de um capacitor padrão) que posso criar usando capacitores que já tenho por aí. A saída e a configuração resultantes são descritas a seguir. Agora sou capaz de sintonizar meu órgão com muito mais eficiência e eficácia nas frequências exatas das notas padrão. Eu gostaria de ter feito isso para começar. Minha música demo no órgão provavelmente teria soado muito melhor.

Valor mais próximo: 27,329 nF Diferença: 0,001 Configuração nFCapacitor: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Equações de equivalência de capacitor de resistor

Para referência, abaixo estão as equações de equivalência para combinar resistores e capacitores em um circuito.

• Resistores em série (R1 + R2): Req = R1 + R2
• Resistores em paralelo (R1 || R2): Req = 1 / (1 / R1 + 1 / R2)
• Capacitores em série (C1 + C2): Ceq = 1 / (1 / C1 + 1 / C2)
• Capacitores em paralelo (C1 || C2): Ceq = C1 + C2

Etapa 2: entradas

Existem 4 entradas que você precisará fornecer:

1. Se você está calculando um valor para um resistor ou um capacitor.
2. A resistência alvo ou valor de capacitância e as unidades.
3. O número máximo de componentes que você gostaria de usar para atingir o valor alvo (ou seja, eu não gostaria de usar mais de 3 resistores para atingir meu valor de resistência alvo).
4. A lista de valores para os resistores / capacitores que você possui atualmente. Esses valores devem estar nas mesmas unidades que seu valor de destino (ou seja, se seu valor de destino era 110 nF, todos os seus valores devem ser fornecidos em nF).

Etapa 3: Resultado

Você obterá 3 saídas para o seu resultado:

1. Valor mais próximo - o valor de resistência / capacitância mais próximo que você conseguiu atingir com seus parâmetros.
2. Diferença - o quão longe o seu valor mais próximo estava do seu valor alvo.
3. Configuração do resistor / capacitor - uma lista de valores dos resistores / capacitores a serem usados e sua configuração.

Etapa 4: Compreendendo o seu resultado

A saída da configuração usa uma notação padrão. "+" significa que os componentes estão em série e "||" significa que os componentes estão em paralelo. Os operadores têm precedência igual e são associativos da esquerda para a direita, o que significa que você agrupa os termos começando da esquerda e movendo para a direita.

Por exemplo, observe o seguinte resultado:

Configuração do resistor: R0 = 15 Ohms + R1 = 470 Ohms || R2 = 3300 Ohms + R3 = 15000 Ohms

Se você seguir as diretrizes discutidas acima, poderá ver que isso é equivalente à seguinte equação e imagem acima.

((R0 + R1) || R2) + R3

Etapa 5: Mais projetos

Para mais projetos, visite minhas páginas:

• https://dargen.io/
• https://github.com/mjdargen
• https://www.instructables.com/member/mjdargen/

Etapa 6: Código Fonte

Para visualizar o código-fonte, visite este repositório Github ou veja o JavaScript abaixo.

/* --------------------------------------------------------------- */

/ * r / c calculator scripting * / / * --------------------------------------- ------------------------- * / var near_val; // valor mais próximo até agora var close_diff = 1000000,00; // diff de val e alvo var mais próximo = ; // array detalhando valores de componentes var ser_par_config = ; // array detalhando serial / paralelo var outputStr = ""; function calculatorClick () {// limpar os valores globais para cada novo clique próximo_val = 0; diferença_de_maispróxima = 1000000,00; mais próximo = ; ser_par_config = ; var resultDisplay = document.getElementById ("resultRow"); var exampleDisplay = document.getElementById ("exampleRow"); var calcOutput = document.getElementById ("calcOutput"); var targetTextObj = document.getElementById ('targetText'); var numCompTextObj = document.getElementById ('numCompText'); var compValsTextObj = document.getElementById ('compValsText'); var target = parseFloat (targetTextObj.value); var numComp = parseInt (numCompTextObj.value); var compValsStr = compValsTextObj.value; var compVals = ; compVals [0] = ""; var i = 0; var errFlag = 0; // erro na análise do valor de destino if (isNaN (target)) {outputStr = "Erro na verificação de 'Valor de destino' input!"} // erro na análise do número de componentes else if (isNaN (numComp)) {outputStr = "Verificação de erro Entrada 'Número de componentes'! "} // else if nenhum erro no destino ou numComp else if (! IsNaN (target) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {var vírgula = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, vírgula)); // erro na análise da lista de valores do componente, definir sinalizador if (isNaN (newInt)) {errFlag = 1; pausa; } compValsStr = compValsStr.substring (vírgula + 1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // erro na análise da lista de valores do componente, definir sinalizador if (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). verificado) {resistor (alvo, numComp, compVals); } else if (document.getElementById ("capRadio"). verificado) {capacitor (target, numComp, compVals); }} // erro na análise da lista de valores do componente else {outputStr = "Erro na verificação da 'Lista de valores do componente' input!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "bloquear"; exampleDisplay.style.display = "flex"; // rolar para baixo até o resultado window.scrollTo (0, exampleDisplay.scrollHeight); } / * Recupera e imprime a melhor configuração de resistor * alvo - valor de resistência alvo * numComp - número total de resistores permitidos para serem usados para atingir o valor alvo * compVals - matriz de valores de resistor * / resistor de função (alvo, numComp, compVals) { // comprimento dos valores de resistência var num_res = compVals.length; // percorre todo o número possível de componentes para (var i = 1; i <= numComp; i ++) {var data = ; resCombinação (compVals, num_res, i, 0, data, target); } var units = document.getElementById ("selected_unit"). value; // imprime os resultados outputStr = "Valor mais próximo:" + valor_próximo.toFixado (3) + "" + unidades + ""; outputStr + = "Diferença:" + mais próxima_diff.toFixado (3) + "" + unidades + ""; outputStr + = "Configuração do resistor:"; para (var i = 0; i <numComp; i ++) {if (i <mais próximo. comprimento) {outputStr + = "R" + i + "=" + mais próximo + "" + unidades + ""; if (i + 1 <mais próximo.length) {if (ser_par_config [i + 1]) outputStr + = "||"; else outputStr + = "+"; }} else break; }} / * Calcula a melhor combinação de resistores para atingir um valor alvo. * res - matriz de entrada de valores de resistor * num_res - tamanho da matriz de entrada de valores de resistor * num_comb - número de resistores permitidos * índice - índice de comb * comb - matriz de combinação atual * alvo - o valor alvo * Sem valor de retorno - passa a melhor combinação atual para valores globais * / função resCombination (res, num_res, num_comb, index, comb, target) {// a combinação atual está completa se (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (número de componentes) var ser_par = ; // array bool especificando serial ou paralelo para cada componente var calc; // valor de resistência equivalente calculado // percorre todas as configurações possíveis de série / paralelo da combinação atual para (var j = 0; j k) & 1; } // faça os cálculos para a combinação baseada na combinação série / paralelo para (var k = 0; k <num_comb; k ++) {// primeiro número, apenas adicione if (k == 0) calc = comb [k]; // zero significa série, adiciona valores de resistência, senão if (! ser_par [k]) calc + = comb [k]; // um significa paralelo, inverso da soma dos recíprocos else if (ser_par [k]) calc = (calc * comb [k]) / (calc + comb [k]); } // verifique se a diferença é menor do que a anterior melhor if (Math.abs (calc - target) <mais próxima_diff) {// é menor, então atualize os valores globais close_val = calc; diferença_mais próxima = Math.abs (calc - alvo); // limpar para zero para (var k = 0; k <num_comb; k ++) {mais próximo [k] = 0; } // atualiza o valor mais próximo & séries / matrizes paralelas para (var k = 0; k <num_comb; k ++) {mais próximo [k] = comb [k]; ser_par_config [k] = ser_par [k]; }}} return 0; } // chama recursivamente e substitui o índice com todos os valores possíveis para (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombinação (res, num_res, num_comb, index + 1, comb, target); }} / * Recupera e imprime a melhor configuração de capacitor * alvo - valor de capacitância alvo * numComp - número total de capacitores que podem ser usados para atingir o valor alvo * compVals - matriz de valores de capacitor * / função capacitor (alvo, numComp, compVals) {// comprimento dos valores de capacitância var num_cap = compVals.length; // percorre todo o número possível de componentes para (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var units = document.getElementById ("selected_unit"). value; // imprime os resultados outputStr = "Valor mais próximo:" + valor_próximo.toFixado (3) + "" + unidades + ""; outputStr + = "Diferença:" + mais próxima_diff.toFixed (3) + "" + unidades + ""; outputStr + = "Configuração do capacitor:"; para (var i = 0; i <numComp; i ++) {if (i <mais próximo.length) {outputStr + = "C" + i + "=" + mais próximo + "" + unidades + ""; if (i + 1 <mais próximo.length) {if (ser_par_config [i + 1]) outputStr + = "||"; else outputStr + = "+"; }} else break; }} / * Calcula a melhor combinação de capacitores para atingir um valor alvo. * cap - matriz de entrada de valores de capacitor * num_cap - tamanho da matriz de entrada de valores de capacitor * num_comb - número de capacitores permitidos * índice - índice de comb * comb - matriz de combinação atual * alvo - o valor alvo * Sem valor de retorno - passa a melhor combinação atual para valores globais * / função capCombination (cap, num_cap, num_comb, index, comb, target) {// a combinação atual está completa se (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (número de componentes) var ser_par = ; // array bool especificando serial ou paralelo para cada componente var calc; // valor de capacitância equivalente calculado // percorre todas as configurações possíveis em série / paralelo da combinação atual para (var j = 0; j k) & 1; } // faça os cálculos para a combinação com base na combinação série / paralelo para (var k = 0; k