La captura de pantalla muestra un resultado en base 2 (es decir, binario) del cálculo de la parte constante de un mapeo. Puede aproximar esta multiplicación por una constante sumando un número de turnos. Primero debes desglosar cada multiplicación en el resultado:

x * 0.001 ₂ = x >> 3

x * 0.0001 _{2 = x >> 4}

x * 0.0000001 ₂ = x >> 7

Luego súmelos. Básicamente, lo está dividiendo en convenientes multiplicaciones de base 2 (que siempre se pueden representar por cambios) y sumas, casi siempre más eficiente.

Esto no lo lleva directamente a 250, pero bastante cerca:

  >>> para i en el rango (0, 1024, 34): ... print (i >> 3) + (i >>weg 4) + (p. [snip] 235241247>>> print (1023 >> 3) + (1023 >> 4) + (1023 Ailiwexnpqnpqgt print (1023 >> 3) + (1023 >> 4) + (1023 Ailiwexnpqt code> ( ADLAR  = 1) sin embargo, para minimizar los errores. El ADC devuelve un resultado de 10 bits y ADLAR elige si está alineado a la izquierda o la derecha de los dos registros de resultados. 

¿Qué tal esto, mapear a 50..249?

  output = ((input * 25) >> 7) +50;  

Su el rango de entrada era 1024 (0..1023). El rango de salida es 200 (en la especificación original, habría sido 201, que no se divide tan claramente). Estos tienen un mcd de 8, por lo que output = (input * (200/8)) / (1024/8) + 50 servirá, y la división por una potencia de 2 se puede expresar con un cambio. Lo bueno es que 1024 * 25 todavía encaja en un entero de 16 bits, por lo que no se necesitan largos.

Si desea un rango completo, puede intentar redondear

  salida = ((entrada * 25 + 64) >> 7) +50;  

Podrías aproximarlo bastante usando solo dos operaciones enteras:

  backlight = (LDRreading / 5) + 46;  

Eso mapea efectivamente la entrada rango 0 - 1023 en el rango de salida 46 - 250, por lo que es bastante preciso. Si LDRreading es un tipo entero de 2 bytes, entonces debería ser significativamente más eficiente (hablando comparativamente) que cualquier cosa que use long .

Si el rango de entrada es de tamaño limitado y tienes la memoria para ello, nada mejor que una simple tabla de búsqueda.

como
unsigned char map [1024] = {50, 50, << más entradas aquí >>, 250};

Puede precalcular el contenido en una parte del programa que no es crítica en el tiempo o simplemente calcular todo el contenido de la tabla de antemano y ponerlo literalmente en el código fuente.

Hacer un mapa es solo una lectura de map [] con el valor original como índice.

Si ingresa el rango comienza con un número distinto de cero, simplemente disminuya todas las entradas por el valor del límite inferior para tiene un índice base 0 para la matriz de mapas. (¡Eso también funciona para límites inferiores negativos!)

Como máximo 1 resta (para ajustar un límite inferior distinto de cero) y 1 adición para calcular el índice base de matriz +.
Y un buen compilador podrá optimizarlo aún más.

No puede ser más eficiente que eso, pero necesita el espacio para guardar la mesa en algún lugar.