Opérateurs arithmétiques à Arduino
- Opérateur d'addition
- Opérateur de soustraction
- Opérateur de multiplication
- Division opérateur
- Opérateur absolu
- Opérateur minimum et maximum
- Opérateur carré
- Opérateur de racine carrée
- Opérateur modulo
- Opérateur électrique
Opérateurs arithmétiques à Arduino
Les opérateurs arithmétiques sont utilisés pour effectuer des fonctions mathématiques de base. Sur la base de ces opérateurs arithmétiques, la logique du programme souhaité peut être conçue. Il y a onze opérateurs utilisés pour les calculs mathématiques qui sont expliqués dans cette rédaction.
Ajout
Lorsque deux nombres ou plus doivent être ajoutés, l'opérateur d'addition est utilisé. Lors de l'écriture du code dans Arduino, les nombres variables ou constants sont déclarés d'abord avec un type de données entier. Après cela, utilisez l'opérateur d'addition «+» pour l'ajout. Cela peut être expliqué en outre par le code ci-dessous:
int a = 4;
int b = 2;
const int C = 1;
int add;
ajouter = a + b + c;
Soustraction
La différence entre deux ou plusieurs valeurs peut être calculée dans la programmation Arduino en utilisant l'opérateur de soustraire «-». Si les deux ou plusieurs nombres doivent être soustraits, ils doivent être déclarés d'abord constants ou variables, ces valeurs peuvent être soustraites à l'aide de l'opérateur de soustraction. Pour mieux comprendre, les déclarations simples sont présentées ci-dessous:
int a = 4;
int b = 2;
Intre soustrait;
soustraire = a-b;
Multiplier
Dans la programmation Arduino, la multiplication de deux constantes et variables peut être effectuée en utilisant le symbole d'astérisque «*». De même, une constante et une variable peuvent également être multipliées en utilisant la même méthode.
int a = 4;
int b = 2;
const int C = 1;
int multiplier;
multiply = a * b * c;
Diviser
Pour diviser les deux des valeurs constantes et des valeurs variables, un symbole «/» en tronçon est utilisé. Le type de variable utilisé pour l'opérateur de division est flottant de sorte que toute sortie non entière peut être acceptée en outre, comme les autres opérateurs une constante et une autre variable peut également être divisée:
int a = 4;
int b = 2;
Float divide;
diviser = a / b;
Absolu
Dans la programmation Arduino pour convertir une valeur négative en une valeur positive, la valeur absolue de cette valeur est prise, que la valeur soit une variable ou une constante. La signification de l'absolu est de dire à quel point un nombre est de 0 sans signifier la direction; Pour prendre absolu en utilisant le code Arduino, la commande ABS est utilisée comme illustré dans les instructions ci-dessous:
int c = -16;
Résultat int;
Résultat = ABS (C);
Ici, en exemple de code, on peut voir que la valeur C est à 16 valeurs de zéro.
Maximum et minimum
La valeur maximale et la valeur minimale entre deux valeurs peut être trouvée en utilisant Max () et min () Fonctions dans le programme Arduino. Les valeurs peuvent être des variables ou des constantes:
// pour maximum
int a = 4;
int b = 2;
int max_output;
max_output = max (a, b);
// pour un minimum
int a = 4;
int b = 2;
int min_output;
min_output = min (a, b);
À partir du code ci-dessus, la sortie de la fonction maximale sera de 4 et pour la fonction minimale, elle sera 2 car quatre est supérieure à 2.
Racine carrée
Pour prendre une racine carrée de toute variable ou valeur constante, la fonction SQRT () est utilisé dans Arduino.De plus, il peut s'expliquer par l'exemple de code donné. La racine carrée de 100 sera de 10:
int y = 100;
int = résultat;
résultat = sqrt (y);
Carré
La fonction utilisée pour prendre le carré de variable et de constante est sq (). De même, les types de données utilisés pour le carré de l'opérateur sont flottants, int, double. Ici dans l'exemple le carré pour 2.8 sera 7.84:
flotter f = 2.8;
float = résultat;
résultat = sq (f);
Modulo
Si deux valeurs sont divisées et qu'elles ne sont pas complètement divisées en conséquence, une valeur de résidus est laissée pour constater que l'opérateur reste de valeur est utilisé en utilisant un symbole en pourcentage «%». Étant donné que dans l'exemple donné, les deux nombres sont complètement divisibles, donc le reste sera nul:
int a = 4;
int b = 2;
Résultat flottant;
résultat = (un% b);
Fonction de puissance
Cet opérateur peut être utilisé pour calculer la valeur de la variable ou de la constante ayant le formulaire exponentiel. La fonction utilisée pour cela est Pow (). Pour donner une meilleure compréhension de l'opérateur, le code pseudo est écrit ci-dessous. Dans l'exemple 4 pour augmenter la puissance 2 est calculé à l'aide de la fonction POW () NAS, la sortie sera 16.
int a = 4;
int b = 2;
Résultat int;
résultat = pow (a, b);
Exemple de code
Les opérateurs arithmétiques expliqués ci-dessus sont compilés ensemble dans un seul programme. Seulement pour l'opérateur de division que la variable de type flotteur est utilisée et pour le reste des opérateurs a des variables de type entier car l'opérateur de division peut avoir des résultats en décimales.
void setup()
// Mettez votre code de configuration ici, pour exécuter une fois:
int a = 4;
int b = 2;
int x = -16;
int y = 100;
flotter f = 2.8;
Résultat int;
float result_fl;
En série.commencer (9600);
En série.print ("addition (a + b):");
résultat = a + b;
En série.println (résultat);
En série.print ("soustraction (a - b):");
résultat = a - b;
En série.println (résultat);
En série.print ("Multiplication (a * b):");
résultat = a * b;
En série.println (résultat);
En série.print ("Division (A / B):");
result_fl = a / b;
En série.println (result_fl);
En série.print ("reste (a% b):");
résultat = un% b;
En série.println (résultat);
En série.print ("Absolu de -16 est:");
En série.println (ABS (x));
En série.print ("La valeur maximale est:");
En série.println (max (a, b));
En série.print ("La valeur minimale est:");
En série.println (min (a, b));
En série.Imprimer ("carré de 2.8 est: ");
En série.println (sq (f));
En série.print ("La valeur pour 4 ^ 2 est:");
résultat = pow (a, b);
En série.println (résultat);
En série.print ("La racine carrée de 100 est:");
résultat = sqrt (y);
En série.println (résultat);
VOID LOOP ()
// Mettez votre code principal ici, pour exécuter à plusieurs reprises:
Sortir
Conclusion
Les opérateurs arithmétiques de la programmation Arduino sont utiles pour déterminer la logique de base derrière laquelle un code s'exécute. Cet article explique ce que sont les opérateurs arithmétiques et comment ils peuvent être utilisés pour les calculs mathématiques qui peuvent être utilisés pour faire des conditions pour que toute tâche spécifique soit effectuée.