Ao dirigir um LED com PWM, o brilho (como eu o percebo) não aumenta linearmente com o ciclo de trabalho. O brilho é lento para aumentar, depois aumenta exponencialmente com o ciclo de trabalho.
Alguém pode sugerir uma regra prática a ser usada como fator de correção ou outra solução alternativa?
Respostas:
Para 16 níveis, é fácil fazer uma tabela de consulta simples "à mão" e converter o valor de 4 bits em um valor de 8 bits para passar para o controlador PWM: esse é o componente que eu usei no meu driver de matriz de led FPGA. Para um controlador de nível de 8 bits, você precisará de pelo menos 11 a 12 bits de saída da tabela de consulta.
fonte
1Em teoria, deveria ser exponencial, mas tenho melhores resultados para o desbotamento usando uma função quadrática.
Eu também acho que você entendeu de trás para a frente. No ciclo de trabalho baixo, o aumento percebido no brilho é muito maior do que no ciclo de trabalho quase completo, onde o aumento no brilho é quase imperceptível.
fonte
Eu estive estudando esse assunto nos últimos dias, pois tenho o mesmo problema ... tentando escurecer os LEDs usando o PWM de uma maneira visivelmente linear, mas quero uma resolução completa de 256 etapas. Tentar adivinhar 256 números para criar manualmente uma curva não é uma tarefa fácil!
Não sou um matemático experiente, mas sei o suficiente para gerar algumas curvas básicas combinando algumas funções e fórmulas sem realmente saber como elas funcionam. Acho que, usando uma planilha (usei o Excel), você pode brincar com um conjunto de números de 0 a 255, colocar algumas fórmulas na próxima célula e fazer um gráfico delas.
Estou usando o pic assembler para fazer o desbotamento e, assim, você pode obter a planilha para gerar o código do assembler com uma fórmula (
="retlw 0x" & DEC2HEX(A2)). Isso torna muito rápido e fácil experimentar uma nova curva.Depois de brincar um pouco com as funções LOG e SIN, a média das duas e algumas outras coisas, eu não conseguia realmente obter a curva certa. O que está acontecendo é que a parte do meio do desbotamento estava acontecendo mais lentamente que os níveis mais baixo e mais alto. Além disso, se um desbotamento for seguido imediatamente por um desbotamento, haverá um aumento acentuado na intensidade. O que é necessário (na minha opinião) é uma curva S.
Uma pesquisa rápida na Wikipedia surgiu com a fórmula necessária para uma curva S. Conectei isso à minha planilha e fiz alguns ajustes para que ele se multiplicasse em meu intervalo de valores e criei o seguinte:
Testei no meu equipamento e funcionou lindamente.
A fórmula do Excel que usei foi esta:
onde A2 é o primeiro valor na coluna A, que aumenta A3, A4, ..., A256 para cada valor.
Não tenho ideia se isso é matematicamente correto ou não, mas produz os resultados desejados.
Aqui está o conjunto completo de 256 níveis que eu usei:
fonte
Eu encontrei esse cara que usa um método que ele chama de "Anti-Log Drive". Aqui está o link de download direto para suas informações.
fonte
Eu estava usando um ATtiny para iluminar meu deck. O brilho é controlado usando um pote conectado ao pino ADC.
Tentei a função exponencial e a saída PWM com base nisso parece estar dando um aumento linear no brilho percebido.
Eu estava usando estas fórmulas:
Attiny85 @ 8MHz estava demorando cerca de 210us para executar o cálculo acima. Para melhorar o desempenho, fez uma tabela de pesquisa. Como a entrada era do ADC de 10 bits e a memória ATtiny é limitada, eu também queria criar uma tabela mais curta.
Em vez de criar tabela de pesquisa com 1024 entradas, crie uma tabela de pesquisa inversa com 256 entradas (512 bytes) na memória do programa (PGMEM). Uma função foi escrita para executar a pesquisa binária nessa tabela. Este método leva apenas 28uS para cada pesquisa. Se eu usar uma tabela de pesquisa direta, isso exigiria 2kb de memória, mas a pesquisa levaria apenas 4uS ou mais.
Os valores calculados na tabela de pesquisa usam apenas a faixa de entrada 32-991, descartando a faixa inferior / superior do ADC, caso haja algum problema com o circuito.
Abaixo está o que eu tenho agora.
// programa de teste anti_log / * LED conectado ao PIN6 (PB1) * / #define LED 1 // Tabela de pesquisa Anti-Log (reversa) // y = 0-255 (saída pwm), y_range = 256 // x = 0-1023 (entrada ADC de 10 bits); // supondo que os valores inferiores / superiores dos valores de saída ADC não possam ser usados // descartando os primeiros 32 e os últimos 32 valores. // min_x = 32, max_x = 1023-min_x, x_range = 1024-2 * min_x // ANTI_LOG [y] = arredondado (intervalo_x * log (y, base = intervalo_y) + min_x) // dado um valor de x, faça uma pesquisa binária na tabela abaixo // leva cerca de 28 uS para o relógio Attiny85 a 8 MHz PROGMEM prog_uint16_t ANTI_LOG [] = { 0x0000, 0x0020, 0x0098, 0x00de, 0x0110, 0x0137, 0x0156, 0x0171, 0x0188, 0x019c, 0x01af, 0x01bf, 0x01ce, 0x01dc, 0x01e9, 0x01f5, 0x0200, 0x020a, 0x0214, 0x021e, 0x0227, 0x022f, 0x0237, 0x023f, 0x0246, 0x024d, 0x0254, 0x025b, 0x0261, 0x0267, 0x026d, 0x0273, 0x0278, 0x027d, 0x0282, 0x0288, 0x028c, 0x0291, 0x0296, 0x029a, 0x029f, 0x02a3, 0x02a7, 0x02ab, 0x02af, 0x02b3, 0x02b7, 0x02bb, 0x02be, 0x02c2, 0x02c5, 0x02c9, 0x02cc, 0x02cf, 0x02d3, 0x02d6, 0x02d9, 0x02dc, 0x02df, 0x02e2, 0x02e5, 0x02e8, 0x02eb, 0x02ed, 0x02f0, 0x02f3, 0x02f5, 0x02f8, 0x02fa, 0x02fd, 0x0300, 0x0302, 0x0304, 0x0307, 0x0309, 0x030b, 0x030e, 0x0310, 0x0312, 0x0314, 0x0317, 0x0319, 0x031b, 0x031d, 0x031f, 0x0321, 0x0323, 0x0325, 0x0327, 0x0329, 0x032b, 0x032d, 0x032f, 0x0331, 0x0333, 0x0334 0x0336, 0x0338, 0x033a, 0x033c, 0x033d, 0x033f, 0x0341, 0x0342, 0x0344, 0x0346, 0x0347, 0x0349, 0x034b, 0x034c, 0x034e, 0x034f, 0x0351, 0x0352, 0x0354, 0x0355, 0x0357, 0x0358, 0x035a, 0x035b, 0x035d, 0x035e, 0x0360, 0x0361, 0x0363, 0x0364, 0x0365, 0x0367, 0x0368, 0x0369, 0x036b, 0x036c, 0x036d, 0x036f, 0x0370, 0x0371, 0x0372, 0x0374, 0x0375, 0x0376, 0x0378, 0x0379, 0x037a, 0x037b, 0x037c, 0x037e, 0x037f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0385, 0x0386, 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038e, 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f, 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x3ac, 0x3ac 0x03ae, 0x03af, 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x3bab, 0x03bab 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03bf, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7 0x03c9, 0x03ca, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03cd, 0x03ce, 0x03cf, 0x03d0, 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d3 0x03d5, 0x03d6, 0x03d6, 0x03d7, 0x03d8, 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03db, 0x03dc, 0x03dd, 0x03dd, 0x03df }; // Pesquisa binária usando a tabela acima. byte antilog (int x) { byte y = 0x80; int av; for (int i = 0x40; i> 0; i >> = 1) { av = pgm_read_word_near (ANTI_LOG + y); se (av> x) { y - = i; } senão se (av <x) { y | = i; } outro { retornar y; } } if (pgm_read_word_near (ANTI_LOG + y)> x) { y = 1; } retornar y; } configuração nula () { pinMode (LED, SAÍDA); digitalWrite (LED, BAIXO); } #define MIN_X 0 #define MAX_X 1024 loop vazio () { int i; // antilog_drive para (i = MIN_X; i <MAX_X; i ++) { analogWrite (LED, anti-log (i)); atraso (2); } para (--i; i> = MIN_X; i--) { analogWrite (LED, anti-log (i)); atraso (2); } atraso (1000); // Movimentação linear para (i = MIN_X; i <MAX_X; i ++) { analogWrite (LED, i >> 2); atraso (2); } para (--i; i> = MIN_X; i--) { analogWrite (LED, i >> 2); atraso (2); } atraso (2000); }fonte
This PDF explains the curve needed, apparently a logarithmic one. If you have a linear dimmer (your PWM value) then the function should be logarithmic.
Here you can find a lookup table for 32 steps of brightness for 8 bit PWM.
Here for 16 steps.
fonte
Here is what I have done based on that arduino forum response. I have computed the values from 0 to 255 so it's easy to use with pwm on arduino
Then to use on Arduino just do like that :
Hope it is helpfull for some people ;)
fonte
I'm dealing with this now, and I'm taking a slightly different approach. I want 256 levels of brightness, but mapping a linear 0-255 range to a non-linear 0-255 range winds up, as you can see in some of the other answers, with a lot of duplicate entries. (I.e., several of your input values result in the same brightness level.)
I tried modifying the algorithm to map a 0-256 input range to a 0-1023 output range, but even that had several values mapping to 0. So I'm trying something a bit different - I'm using the 0-255 level to generate non-linear values in the range 0-769 (that's 1023 minus 255) using
sin(), then add that to the input level to get an output in the range 0-1023 with no duplicates. I'll configure a timer to use a counter of 1023, and set the comparator for the PWM output to values from the lookup table based on what lighting level I want (0-255).Here's the C program I used to generate my lookup table:
And here's the table:
I'll probably investigate other functions (like
log()) once I've got this up and running.fonte
For me this law seem to work pretty good: http://www.pyroelectro.com/tutorials/fading_led_pwm/theory2.html
fonte