Al conducir un LED con PWM, el brillo (como lo percibo) no se escala linealmente con el ciclo de trabajo. El brillo es lento para aumentar, luego aumenta exponencialmente con el ciclo de trabajo.
¿Alguien puede sugerir una regla general para usar como factor de corrección u otra solución?
Respuestas:
Para 16 niveles, es fácil hacer una tabla de búsqueda simple "a mano" y convertir el valor de 4 bits en un valor de 8 bits para pasar al controlador PWM: este es el componente que he usado en mi controlador de matriz de LED FPGA. Para un controlador de nivel de 8 bits, necesitará al menos una salida de 11-12 bits de la tabla de búsqueda.
fuente
1En teoría, debería ser exponencial, pero obtuve los mejores resultados para el desvanecimiento mediante el uso de una función cuadrática.
También creo que lo tienes al revés. En el ciclo de trabajo bajo, el aumento percibido del brillo es mucho mayor que en el ciclo de trabajo casi completo, donde el aumento del brillo es casi imperceptible.
fuente
He estado investigando este tema en los últimos días ya que tengo el mismo problema ... tratando de atenuar los LED usando PWM de una manera visiblemente lineal, pero quiero una resolución completa de 256 pasos. ¡Intentar adivinar 256 números para crear una curva manualmente no es una tarea fácil!
No soy un matemático experto, pero sé lo suficiente como para generar algunas curvas básicas combinando algunas funciones y fórmulas sin saber realmente cómo funcionan. Me parece que usando una hoja de cálculo (usé Excel) puedes jugar con un conjunto de números del 0 al 255, poner algunas fórmulas en la siguiente celda y representarlas gráficamente.
Estoy usando pic assembler para hacer el desvanecimiento, por lo que incluso puede obtener la hoja de cálculo para generar el código del ensamblador con una fórmula (
="retlw 0x" & DEC2HEX(A2)). Esto hace que sea muy rápido y fácil probar una nueva curva.Después de jugar un poco con las funciones LOG y SIN, el promedio de los dos y algunas otras cosas, realmente no pude obtener la curva correcta. Lo que está sucediendo es que la parte media del desvanecimiento fue más lenta que los niveles más bajos y más altos. Además, si un desvanecimiento es seguido inmediatamente por un desvanecimiento, hubo un fuerte aumento notable en la intensidad. Lo que se necesita (en mi opinión) es una curva en S.
Una búsqueda rápida en Wikipedia arrojó la fórmula necesaria para una curva en S. Lo conecté a mi hoja de cálculo e hice algunos ajustes para que se multiplique en mi rango de valores, y se me ocurrió esto:
Lo probé en mi plataforma y funcionó muy bien.
La fórmula de Excel que utilicé fue esta:
donde A2 es el primer valor en la columna A, que aumenta A3, A4, ..., A256 para cada valor.
No tengo idea si esto es matemáticamente correcto o no, pero produce los resultados deseados.
Aquí está el conjunto completo de 256 niveles que utilicé:
fuente
Encontré a este tipo que usa un método que él llama "Anti-Log Drive". Aquí está el enlace de descarga directa para su información.
fuente
Estaba usando un ATtiny para iluminar mi terraza. El brillo se controla usando una olla conectada al pin ADC.
Intentó la función exponencial y la salida PWM basada en eso parece estar dando un aumento lineal en el brillo percibido.
Estaba usando estas fórmulas:
Attiny85 @ 8MHz estaba tardando unos 210us en realizar el cálculo anterior. Para mejorar el rendimiento, hizo una tabla de búsqueda. Como la entrada era de ADC de 10 bits y la memoria ATtiny es limitada, también quería crear una tabla más corta.
En lugar de hacer una tabla de búsqueda con 1024 entradas, hizo una tabla de búsqueda inversa con 256 entradas (512 bytes) en la memoria del programa (PGMEM). Se escribió una función para realizar una búsqueda binaria en esa tabla. Este método solo requiere 28uS para cada búsqueda. Si uso una tabla de búsqueda directa, requeriría 2kb de memoria, pero la búsqueda tomaría solo 4 uS más o menos.
Los valores calculados en la tabla de búsqueda usan solo el rango de entrada 32-991, descartando el rango inferior / superior de ADC, en caso de que haya un problema con el circuito.
A continuación se muestra lo que tengo ahora.
// programa de prueba anti_log / * LED conectado a PIN6 (PB1) * / #define LED 1 // tabla de búsqueda Anti-Log (inversa) // y = 0-255 (salida pwm), rango_y = 256 // x = 0-1023 (entrada ADC de 10 bits); // suponiendo que no se pueden usar valores de salida ADC inferior / superior // descartando los primeros 32 y los últimos 32 valores. // min_x = 32, max_x = 1023-min_x, x_range = 1024-2 * min_x // ANTI_LOG [y] = round (x_range * log (y, base = y_range) + min_x) // dado un valor de x, realice una búsqueda binaria en la tabla a continuación // toma aproximadamente 28uS para el reloj Attiny85 @ 8MHz 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, 0x02b7, 0x02b7, 0x02b7, 0x02b7, 0x02b7, 0x02b7 0x02be, 0x02c2, 0x02c5, 0x02c9, 0x02cc, 0x02cf, 0x02d3, 0x02d6, 0x02d9, 0x02dc, 0x02df, 0x02e2, 0x02e5, 0x02e8, 0x02e8, 0x02e8, 0x02e8, 0x02e8, 0x02e8, 0x02e8 0x02f0, 0x02f3, 0x02f5, 0x02f8, 0x02fa, 0x02fd, 0x0300, 0x0302, 0x0304, 0x0307, 0x0309, 0x030b, 0x030e, 0x0310, 0x0312, 0x0312 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, 0x03ac, 0x33, 0x3, 0 0x03ae, 0x03af, 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba, 0x03ba, 0x03ba, 0x03ba, 0x03ba, 0x03ba, 0x03ba, 0x03 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03bf, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c7, 0x03c7, 0x03c7, 0x03c7, 0x03c7, 0x03c7, 0x03c7 0x03c9, 0x03ca, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03cd, 0x03ce, 0x03cf, 0x03d0, 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d3, 0x03 0x03d5, 0x03d6, 0x03d6, 0x03d7, 0x03d8, 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03db, 0x03dc, 0x03dd, 0x03dd, 0x03df, 0x03df, 0x03df, 0x03df, 0x03 }; // Búsqueda binaria usando la tabla anterior. byte antilog (int x) { byte y = 0x80; int av; para (int i = 0x40; i> 0; i >> = 1) { av = pgm_read_word_near (ANTI_LOG + y); si (av> x) { y - = i; } más si (av <x) { y | = i; } más { volver y; } } if (pgm_read_word_near (ANTI_LOG + y)> x) { y - = 1; } volver y; } configuración nula () { pinMode (LED, SALIDA); digitalWrite (LED, BAJO); } #define MIN_X 0 #define MAX_X 1024 bucle vacío () { int i; // antilog_drive para (i = MIN_X; i <MAX_X; i ++) { analogWrite (LED, antilog (i)); retraso (2); } para (--i; i> = MIN_X; i--) { analogWrite (LED, antilog (i)); retraso (2); } retraso (1000); // accionamiento lineal para (i = MIN_X; i <MAX_X; i ++) { analogWrite (LED, i >> 2); retraso (2); } para (--i; i> = MIN_X; i--) { analogWrite (LED, i >> 2); retraso (2); } retraso (2000); }fuente
Este PDF explica la curva necesaria, aparentemente una logarítmica. Si tiene un atenuador lineal (su valor PWM), entonces la función debe ser logarítmica.
Aquí puede encontrar una tabla de búsqueda para 32 pasos de brillo para PWM de 8 bits.
Aquí por 16 pasos.
fuente
Esto es lo que he hecho en base a esa respuesta del foro arduino . He calculado los valores de 0 a 255, por lo que es fácil de usar con pwm en arduino
Luego, para usar en Arduino, simplemente haga así:
Espero que sea útil para algunas personas;)
fuente
Estoy lidiando con esto ahora, y estoy tomando un enfoque ligeramente diferente. Quiero 256 niveles de brillo, pero el mapeo de un rango lineal de 0-255 a un rango no lineal de 0-255 termina, como puede ver en algunas de las otras respuestas, con muchas entradas duplicadas. (Es decir, varios de sus valores de entrada dan como resultado el mismo nivel de brillo).
Traté de modificar el algoritmo para asignar un rango de entrada 0-256 a un rango de salida 0-1023, pero incluso eso tenía varios valores de asignación a 0. Así que estoy intentando algo un poco diferente: estoy usando el nivel 0-255 para generar valores no lineales en el rango 0-769 (eso es 1023 menos 255) usando
sin(), luego agregue eso al nivel de entrada para obtener una salida en el rango 0-1023 sin duplicados. Configuraré un temporizador para usar un contador de 1023 y estableceré el comparador para la salida PWM a los valores de la tabla de búsqueda en función del nivel de iluminación que quiero (0-255).Aquí está el programa C que usé para generar mi tabla de búsqueda:
Y aquí está la tabla:
Probablemente investigaré otras funciones (como
log()) una vez que tenga esto en funcionamiento.fuente
Para mí, esta ley parece funcionar bastante bien: http://www.pyroelectro.com/tutorials/fading_led_pwm/theory2.html
fuente