Algoritmo para la asignación de rangos de valores

Question

Mi pregunta quizá pertenezca a la prueba de capacidad general o algo así. No está directamente relacionada con los dispositivos embebidos.

Me han dado una resistencia variable que puede girar infinitamente y es de 10k. El ADC está configurado para un rango de valores de 0 a 1023 de muestreo. Por lo que tengo que controlar la luminosidad/intensidad de la luz.

El rango de valores del ADC se divide en 32 pasos para 1024/32 niveles de luminosidad. El problema es que hay que girar el bote 16 veces para llegar a los extremos. Lo cual es muy molesto. Ahora su tiempo cuando no puedo cambiar el hardware de la olla, pero el firmware.

He pensado en hacer lo siguiente, por favor ayúdenme desde aquí:

Elegiré una ventana de rango dentro de [0 1023], digamos de 32 pasos. Vamos a ignorar el ruido del ADC por ahora.

Entonces tenemos 32 pasos en esas ventanas de 32 pasos.

Si empiezo desde 0, la intensidad irá aumentando hasta 32. El 32 es la máxima intensidad posible. Entonces, si giro más, la intensidad debería permanecer en el máximo de 32 hasta 1023.

Y en cuanto se empiece a disminuir desde 1023, tendré disminución de la intensidad hasta ( 1023-32 ) y permanecerá en intensidad 0 todo el tiempo hasta 0.

si giro hacia atrás desde cualquier lugar debería seguir la regla de la ventana móvil explicada anteriormente. ¿Cómo empezar con ello?

---

Hice lo siguiente:

 void processADC_data()
 {
        ushort adc0 = (ushort)ADC_DATA;
        adc0_Avg = adc0;

        // If Noise 
        /*
        ushort adc0_L = (ushort)(adc0 - 40);
        ushort adc0_H = (ushort)(adc0 + 40);

        adc0 = (ushort)read_ADC( adc0_L,adc0_H );

        adc0_Avg = adc0 * 20 + adc0_Avg * 80;
        adc0_Avg /= 100;
        */

        IsInceasing = (adc0_last - adc0_Avg) < 0 ;
        adc0_last = adc0_Avg;

        if (IsInceasing)
        {

            // Extrimity has to be handled 
            if (!HasPerformedIncreased)
            {
                adc0_center = (ushort)(adc0_Avg - window);
                HasPerformedIncreased = true;
                HasPerformedDecrease = false;
            }
            else if (HasPerformedIncreased)
            {
                IsCrossingLimit = ( (adc0_Avg - adc0_center) > window );
                if(IsCrossingLimit)
                {
                    adc0_Avg = LIGHT_SENS_MAX;
                    IsCrossingLimit = false;
                }
                else
                {
                    adc0_Avg = (ushort)(adc0_Avg / LIGHT_SENS_MAX);
                }
            }

            //judge_brightness(adc0_Avg);
        }
        else
        {
            // Extrimity has to be handled 
            if (!HasPerformedDecrease)
            {
                adc0_center = (ushort)(adc0_Avg + window);
                HasPerformedDecrease = true;
                HasPerformedIncreased = false;
            }
            else if (HasPerformedDecrease)
            {
                IsCrossingLimit = ( (adc0_center - adc0_Avg) > window );
                if(IsCrossingLimit)
                {
                    adc0_Avg = LIGHT_SENS_MIN;
                    IsCrossingLimit = false;
                }
                else
                {
                    adc0_Avg = (ushort)(adc0_Avg / LIGHT_SENS_MAX);
                }
            }

        }

            brightness(adc0_Avg);

    }

Gracias

Answer 1

Suponiendo que tu bote sea lineal, podrías medir la tasa de cambio. A continuación, incremente (o disminuya) su nivel de brillo como una función de software de la tasa de cambio.

De esta manera, puede hacer que su brillo más con un giro más rápido.

Answer 2

En pseudocódigo

// initialization
previous = ADC()
brightness = 0

process ADC:
   new = ADC()
      // must use towards-0 division!
      // divide-by-2 because each 1024/16 turn must give 32 steps
   delta = ( new - previous ) / 2   
   if( delta > 0 ):
      brightness = min( brightness + delta, maximum )
      previous = new
   if( delta < 0 ):
      brightness = max( brightness - delta, minimum )
      previous = new