La cartographie numérique de la gamme sur un autre

Mathématiques n'a jamais été mon fort à l'école 🙁

int input_start = 0; //The lowest number of the range input.
int input_end = 254; //The lowest number of the range input.
int output_start = 500; //The lowest number of the range output.
int output_end = 5500; //The largest number of the range ouput.

int input = 127; //Input value.
int output = 0;

Comment puis-je convertir la valeur d'entrée à la sortie correspondante de la valeur de cette gamme?

Par exemple, une valeur d'entrée de "0" serait égal à une valeur de sortie de "500", une valeur d'entrée de "254" serait égal à une valeur de sortie de "5500". Je ne peux pas comprendre comment calculer une valeur de sortie si une valeur d'entrée est de 50 ou 101.

Je suis sûr que c'est simple, je ne peux pas penser tout de suite 🙂

Edit: j'ai juste besoin des nombres entiers, pas de fractions ou de quoi que ce soit.

InformationsquelleAutor Joe | 2011-04-20

arduino c math

91

Oublions les mathématiques et essayer de le résoudre de manière intuitive.

Tout d'abord, si nous voulons carte d'entrée dans la plage [0, x] à la plage de sortie [0, y], nous avons juste besoin à l'échelle d'un montant approprié. 0 va 0, x va à y, et un certain nombre t ira à (y/x)*t.

Donc, nous allons réduire le problème à la ci-dessus de plus simple problème.

Une gamme d'entrée de [input_start, input_end] a input_end - input_start + 1 numéros. C'est donc l'équivalent d'une gamme de [0, r], où r = input_end - input_start.

De même, la plage de sortie est équivalent à [0, R], où R = output_end - output_start.

Une entrée de input est équivalent à x = input - input_start. Cela, dans le premier alinéa, la traduira y = (R/r)*x. Ensuite, nous pouvons traduire le y valeur initiale de la plage de sortie en ajoutant output_start: output = output_start + y.

Ce qui nous donne:
```
output = output_start + ((output_end - output_start) / (input_end - input_start)) * (input - input_start)
```
Ou, d'une autre manière:
```
/* Note, "slope" below is a constant for given numbers, so if you are calculating
   a lot of output values, it makes sense to calculate it once.  It also makes
   understanding the code easier */
slope = (output_end - output_start) / (input_end - input_start)
output = output_start + slope * (input - input_start)
```
Maintenant, ceci étant C, et la division dans C tronque, vous devriez essayer d'obtenir une réponse plus précise par le calcul de choses à virgule flottante:
```
double slope = 1.0 * (output_end - output_start) / (input_end - input_start)
output = output_start + slope * (input - input_start)
```
Si l'on voulait pour être encore plus précis, vous feriez un arrondi à la place de la troncature dans l'étape finale. Vous pouvez le faire en écrivant un simple round fonction:
```
#include <math.h>
double round(double d)
{
    return floor(d + 0.5);
}
```
Alors:
```
output = output_start + round(slope * (input - input_start))
```
- cela a fonctionné parfaitement, merci beaucoup!
- J'ai écrit cette fonction au moins quelques fois au cours des décennies, et pourtant, cette explication est mieux que je pouvais donner à moi-même. +1 pour la sortir, la division a été utile pour 6,5 millions de calculs à exécuter.
- C'est l'une des meilleures réponses que j'ai vu sur ce site. Merci!!!!
InformationsquelleAutor Alok Singhal

Arduino est ce que carte.

Exemple:

/* Map an analog value to 8 bits (0 to 255) */
void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

Il dispose également de la mise en œuvre sur cette page:

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Pour info, leur map fonction est cassé. Il a été converti à partir d'un virgule flottante fonction en changeant simplement tous les arguments de type int, et il a une fracture de la distribution.

InformationsquelleAutor Dustin

11

Le point crucial ici est de faire la division entière (qui comprend l'arrondissement) au bon endroit. Aucune réponse jusqu'à présent obtenu les parenthèses à droite. Ici est la bonne façon:
```
int input_range = input_end - input_start;
int output_range = output_end - output_start;

output = (input - input_start)*output_range / input_range + output_start;
```
InformationsquelleAutor Sven Marnach
10

la formule est

f(x) = (x - input_start) /(input_end - input_start) * (output_end -
output_start) + output_start

Je vais accrocher cette post ici: https://betterexplained.com/articles/rethinking-arithmetic-a-visual-guide/ comme il m'a beaucoup aidé lorsque vous essayez de venir avec cela intuitivement. Une fois que vous comprenez ce que le poste est en train de dire, c'est trivial à venir avec ces formules sur votre propre. Notez que j'ai utilisé à la lutte avec de telles questions. (Je n'ai pas d'affiliations - juste trouvé très utile)

dire que vous avez de la gamme [input_start..input_end], nous allons commencer par la normalisation tel que 0 est input_start, et 1 est input_end. c'est une technique simple pour faire plus facilement le problème.

comment faisons-nous cela? nous allons, que nous aurions du changement tout à gauche par input_start montant, de sorte que si l'entrée x arrive à être input_start, elle devrait donner à zéro.

donc, disons que f(x) est la fonction qui fait la conversion.
```
f(x) = x - input_start
```
essayons:
```
f(input_start) = input_start - input_start = 0
```
fonctionne pour input_start.

à ce stade, il ne fonctionne pas pour input_end pourtant, comme nous n'avons pas mis à l'échelle il.

disons simplement échelle vers le bas par la longueur de la plage, puis nous allons avoir la plus grande valeur (input_end) mappé à un.
```
f(x) = (x - input_start) / (input_end - input_start)
```
ok, nous allons faire un essai avec input_end.

f(input_end) = (input_end - input_start) /(input_end - input_start) = 1

génial, semble fonctionner.

bon, prochaine étape, nous allons effectivement échelle à la plage de sortie. Il est aussi trivial que simplement en multipliant la longueur réelle de la gamme de sortie, en tant que tel:
```
f(x) = (x - input_start) / (input_end - input_start) * (output_end - output_start)
```
maintenant, en fait, nous avons presque terminé, nous avons juste à le déplacer vers la droite de sorte que 0 commence à partir de output_start.
```
f(x) = (x - input_start) / (input_end - input_start) * (output_end - output_start) + output_start
```
nous allons lui donner un essai rapide.
```
f(input_start) = (input_start - input_start) / (input_end - input_start) * (output_end - output_start) + output_start
```
vous voyez que la première partie de l'équation est à peu près multiplié par zéro, annulant ainsi tout en vous donnant
```
f(input_start) = output_start
```
essayons input_end ainsi.
```
f(input_end) = (input_end - input_start) / (input_end - input_start) * (output_end - output_start) + output_start
```
qui à son tour va finir comme:
```
f(input_end) = output_end - output_start + output_start = output_end
```
comme vous pouvez le voir, il semble maintenant être mappé correctement.

InformationsquelleAutor Erti-Chris Eelmaa
2
```
output = ((input - input_start)/(input_end - input_start)) * (output_end - output_start) + output_start
```
Ce qui n'est de trouver proportionnellement "comment loin dans" la plage d'entrée les données d'entrée. Puis, il s'applique à la proportion de la taille de la sortie de la gamme à savoir dans l'absolu, à quelle distance dans la plage de sortie, la sortie doit être. Il ajoute ensuite le début de la plage de sortie pour obtenir le véritable nombre de sortie.
- Ce sera toujours 500, sauf pour l'entrée 254, qui permettra de 5500.
InformationsquelleAutor QuantumMechanic

Vous devez vous connecter pour publier un commentaire.