Atenuación de LED multiplexados

Para empezar, no uso ni he usado Arduino, pero estoy muy familiarizado con los chips AVR y el ATmega328p en particular. Si lo entiendo correctamente, está tratando de atenuar una matriz de LED de 4x8. Toda la matriz debe atenuarse de una vez, pero no todos los LED estarán siempre encendidos, lo que significa un control de encendido/apagado individual con atenuación colectiva. Esto es realmente una cosa muy simple de hacer. Permítanme comenzar explicando el control PWM, ya que mencionó que es posible que no lo esté haciendo correctamente.

Si tengo un LED y una resistencia en serie y conecto 5 V, brillará con cierto brillo, un factor de la corriente a través del LED, establecido por la resistencia en serie. Si bajo el voltaje, la corriente también bajará y el LED se atenuará. Si envío un pulso al LED, el voltaje efectivo del LED será un promedio de los estados de encendido y apagado del pulso. Este porcentaje de tiempo se conoce como el ciclo de trabajo. La frecuencia del pulso en sí es la frecuencia con la que se repite. Por ejemplo, para crear un pulso de 100 Hz con un ciclo de trabajo del 50 %, me gustaría encender una señal durante 5 ms y luego apagarla durante 5 ms. El período total es de 10 ms. Frecuencia = inversa de Período = 1/10ms = 100Hz. El ciclo duy es 5ms/10ms = 50%.

Los LED pueden encenderse y apagarse muy rápidamente, pero el ojo humano no puede distinguir estos cambios por encima de cierta frecuencia; este valor es diferente para diferentes personas. Teniendo en cuenta que un televisor se actualiza a 60 Hz en los EE. UU. (50 Hz en otros lugares), podemos decir con seguridad que 50 Hz es un buen mínimo, aunque muchos estudios han demostrado que con los LED, ciertas frecuencias pueden hacer que el LED parezca más brillante con el mismo ciclo de trabajo. . Un número común es 100Hz.

Controlar un solo LED e incluso grupos de esta manera es muy simple usando un temporizador. El siguiente código permitirá que el temporizador 1 se ejecute a 125 Hz (período de 8 ms) con Fcpu = 16 MHz.

  #define _BV(FOO) (1<<FOO)
  // Set up Timer 1 for 125Hz LED pulse to control brightness
  PRR &= ~_BV(PRTIM1);                  // Enable Timer1 Clock
  TCCR1A = 0x00;                        // Outputs Disconnected
  TCCR1B = _BV(WGM12) |                 // CTC Mode, Top = OCR1A
           _BV(CS11) | _BV(CS10);       // Prescaler = 64
  OCR1A = 1999;                         // Top = (16MHz * 8ms / 64)-1
  OCR1B = LED_DUTY_CYCLE;               // LED PUlse Width
  TIMSK1 = _BV(OCIE1B) | _BV(OCIE1A);   // Interrupts Enabled

En este código, la coincidencia de comparación A ocurrirá cada 8 ms, creando un pulso de 125 Hz. La coincidencia de comparación B ocurrirá en cualquier valor que se defina como "LED_DUTY_CYCLE". Para un ciclo de trabajo del 80 %, como mencionó, configure OCR1B en 1600. Este valor también se puede cambiar en el código, como cuando un usuario presiona un botón de función de atenuación.

El control de LED tendrá lugar en el ISR para las dos coincidencias de comparación. La variable "salidas" se actualiza en el programa principal cada vez que un LED debe estar encendido o apagado. Cada bit de esta variable se asigna a un LED. Por ejemplo, para encender los LED 0 y 5, las salidas deben establecerse en 0b00100001 en principal. La variable "brillo" se puede actualizar en principal para controlar el ciclo de trabajo de los LED. En el COMPA ISR se encenderán los LEDs que estén habilitados por “salidas”. Luego, todos los LED deben estar apagados en el COMPB ISR.

ISR(TIMER1_COMPA_vect){
  PORTD = (outputs & 0xFF);         // Turn On LEDs Q0 - Q7
  OCR1B = brightness;               // Set the pulse width
}
ISR(TIMER1_COMPB_vect){
  PORTD = 0x00;                     // Turn Off LEDs Q0 - Q7
}

En este ejemplo, hay 8 LED conectados a cada uno de los 8 pines de PORTD. Podrían colocarse en cualquier lugar, esto solo hace que el ejemplo de código sea más fácil de leer. Si los LED están dispersos, deberá hacer algo más como esto:

if(outputs & 0x01) PORTD |= LED0; 
if(outputs & 0x02) PORTD |= LED1;
if(outputs & 0x04) PORTC |= LED2;
//...
if(outputs & 0x40) PORTB |= LED6;
if(outputs & 0x80) PORTB |= LED7;

Tenga en cuenta que cada LED está asignado a un bit en "salidas", pero los propios LED residen en varios puertos IO. Cualquier LED que esté habilitado se encenderá.

Controlar una matriz es un poco más complejo ya que solo una columna estará activa a la vez. Con eso en mente, el ciclo de trabajo más alto posible que puede lograr es del 25 %, incluso si las filas de LED estuvieran encendidas todo el tiempo. Eso es porque cada columna solo estaría en 1/4 del tiempo total. Si hay más de una columna encendida a la vez, perderá por completo la capacidad de encender y apagar los LED individuales. Otra cosa a tener en cuenta con una matriz es el consumo actual. Dependiendo de su definición de fila y columna, tendrá 4 bancos de 8 u 8 bancos de 4 LED paralelos. Si todos los cátodos están unidos, entonces ese pin IO está hundiendo la corriente a través de todos los LED. El ATmega328p tiene una corriente máxima de 40 mA por pin y un total de 200 mA en cualquier momento. El problema de los pines individuales podría evitarse fácilmente hundiendo los LED a través de un "

Por supuesto, todo se puede girar 90 grados para adaptarse a sus necesidades. En cualquier caso, las 8 líneas "CTRL" encenderán un LED siempre que la señal "COLUMNA" apropiada también sea alta. El control de la columna debe ser simple y se puede realizar en la interrupción principal o del temporizador, pero la frecuencia PWM debe ser aproximadamente 4 veces más rápida que la frecuencia de conmutación de la columna para garantizar que la atenuación de los LED aún funcione correctamente. En ese caso, cada columna se pulsaría cuatro veces antes de que se encienda la siguiente columna. Pero, como dije, con 4 columnas, cada LED solo estará encendido el 25 % del tiempo como máximo, por lo que si su función PWM está configurada en 80 %, el LED está realmente solo en .8 * .25 = 20 % de el tiempo. Además, no olvide que a medida que la columna activa cambia, el control cambia de un banco de LED al siguiente, por lo que las "salidas"

También es de destacar que no importa lo que pulse para atenuar los LED. En el ejemplo anterior, estaba pulsando las filas porque es fácil habilitar un LED específico de esa manera. Pulsar la señal de control de la columna a la puerta FET también funcionaría. Por último, dado que solo hay una columna activa a la vez, cada fila compartida puede compartir una resistencia. Cada columna no puede compartir una resistencia porque el brillo individual de los LED cambiaría dependiendo de cuántos estén encendidos o apagados.

Comenzaría eliminando las operaciones de punto flotante dentro de una interrupción en un AVR porque pueden hacer un uso intensivo de la CPU y, dependiendo de la velocidad del reloj, tal vez la interrupción no se complete cuando el temporizador esté listo para dispararse a continuación. Por ejemplo cambiar:

uint8_t pwmMax = 10;
float pwmLevel = 0.8f;
....
if(pwmStep < pwmLevel*pwmMax)

a:

uint8_t pwmMax = 100;
uint8_8 pwmLevel = 80;
if(pwmStep < pwmLevel)

Idealmente, para PWM, desearía intercalar la conmutación, por lo que, por ejemplo, en este momento, digamos más de 10 interrupciones, estará haciendo lo siguiente:

1 1 1 1 1 1 1 1 0 0

Mientras que la siguiente secuencia sería ideal:

1 1 1 1 0 1 1 1 1 0

Sin embargo, eso complicaría las cosas y, a más de 50 Hz, no esperaría que el parpadeo fuera visible, por lo que no parece ser su problema real.

Discrepo respetuosamente con PeterJ sobre el intercalado: si bien es cierto que esto es ideal, ningún atenuador LED comercial hace esto, AFAIK. Todos los que he visto no intercalan los ciclos de encendido y apagado de la manera que sugieres. Y dado un PWM lo suficientemente rápido, realmente no importa.

Una cosa a tener en cuenta es que el mapeo de PWM a intensidad no es lineal, sino exponencial. Usando potencias de dos, el número de ciclos que el LED necesita para encenderse es 2^(intensidad) o 2^(intensidad)-1. Mi preferencia es por lo último, así que iremos con eso. Esto significa que para 4 intensidades (niveles de intensidad 0-3) necesita dividir su período PWM en 7 ciclos y sus LED deben estar encendidos durante 0, 1, 3 y 7 ciclos respectivamente.

Por supuesto, esto tampoco resuelve tu problema. ¿Necesita atenuar los LED de forma individual o colectiva? Si es lo último, puede usar las instalaciones PWM de AVR y no codificar las suyas propias. Si se trata de un chip AVR listo para usar, tiene el divisor 8x, por lo que está ejecutando 1 mhz, y podría ser el caso de que su código pwm sea demasiado lento. Puede apagarlo sin quemar fusibles de la siguiente manera:

CLKPR = (1<<CLKPCE);  // CLKPCE bit must be set immediately before CLKPS bits
CLKPR = 0;  // System clock divider = 1

Esto al menos debería hacer que sus LED parpadeen más rápido :) Pero en cualquier caso, un diagrama de circuito sería útil.