Comment trouver le reste de nombres dans Arduino en utilisant l'opérateur modulo

L'opérateur modulo (%) peut diviser deux nombres et nous donner le reste de l'opération de division. Il est souvent utilisé pour découvrir si une valeur donnée est uniforme ou étrange. En utilisant l'opérateur modulo, nous pouvons contrôler le matériel et concevoir différentes applications en conséquence. Cet article couvrira les bases de l'opérateur modulo et comment il peut être utilisé dans la programmation Arduino.

Table des matières

• Quel est l'opérateur modulo?
  • Syntaxe
  • Paramètre
  • Retour
• Comment utiliser l'opérateur modulo dans Arduino
• Exemple de programme utilisant l'opérateur modulo dans Arduino
• Comment utiliser l'opérateur modulo pour vérifier les nombres uniques ou impairs dans Arduino
• Limitations de l'opérateur modulo
• Conclusion

Quel est l'opérateur modulo?

L'opérateur modulo est une opération mathématique qui effectue la division de deux valeurs et en retour nous donne leur reste. Disons que nous avons une valeur de 9 et l'autre est 2 lorsque nous diviserons les deux, le reste sera 1. Pour obtenir le reste du nombre dans Arduino, le signe en pourcentage (%) est utilisé, ce qui est un symbole pour l'opérateur modulo.

Cet opérateur de modulo est couramment utilisé dans la programmation Arduino pour maintenir une variable dans une plage spécifique, comme la taille d'un tableau.

Syntaxe

La syntaxe pour l'opération restante est la suivante:

reste = dividende% diviseur;

Paramètre

L'opérateur modulo prend les paramètres suivants:

• reste: C'est une variable qui stockera la valeur reste. Les types de données autorisés sont int, flotter et double.
• dividende: Il est variable ou constant. C'est la valeur entière qui est divisée par un autre entier. Le type de données autorisé est int.
• diviseur: C'est la variable non nulle avec une valeur qui divise un autre entier. Le type de données autorisé pour le diviseur est int.

Retour

Cette fonction renvoie le reste de deux nombres lorsqu'il est divisé.

Comment utiliser l'opérateur modulo dans Arduino

Pour utiliser l'opérateur modulo à Arduino, vous utilisez simplement le pourcentage de signe entre deux nombres. Voici un exemple:

int reste = 10% 3; // reste équivaut à 1

Dans cet exemple, nous utilisons l'opérateur modulo pour trouver le reste de 10 divisé par 3. Le résultat est 1, qui est stocké dans le reste variable.

Exemple de programme utilisant l'opérateur modulo dans Arduino

Regardons un programme complet qui utilise l'opérateur modulo pour trouver le reste de deux nombres:

int num1 = 10;
int num2 = 3;
int reste = num1% num2;
void setup()
En série.commencer (9600);

VOID LOOP ()
En série.imprimer ("reste de");
En série.print (num1);
En série.imprimer ("et");
En série.print (num2);
En série.print ("est:");
En série.println (reste);
retard (10000);

Le code commence par définir des variables, num1 et num2. Leur valeur est fixée à 10 et 3, respectivement. Nous utilisons ensuite l'opérateur modulo qui sortira le reste après avoir divisé ces deux nombres. La valeur reste sera enregistrée dans un nom de variable reste. Enfin, nous utilisons la série.Fonction println () pour imprimer la valeur du reste au moniteur série.

Comment utiliser l'opérateur modulo pour vérifier les nombres uniques ou impairs dans Arduino

L'opérateur modulo est également utile pour vérifier si un nombre est même ou impair. Lorsque nous divisons un certain nombre avec 2 et si le reste est nul, cela signifie que la valeur d'entrée est uniforme tandis que si nous obtenons une valeur du reste, il montre que le nombre est impair. Voici un exemple:

void setup()
En série.commencer (9600);
alors que (!En série); // attendez que le moniteur série s'ouvre
En série.println ("Entrez un numéro:");

VOID LOOP ()
si (série.disponible())
int num = série.parseInt ();
if (num% 2 == 0)
En série.print (num);
En série.println ("est même");
autre
En série.print (num);
En série.println ("est impair");

// attendez l'entrée suivante
En série.println ("Entrez un autre numéro:");

Le code a commencé par vérifier l'entrée utilisateur. Il entre ensuite dans la fonction Loop (), qui vérifie si l'utilisateur a entré un numéro en appelant le En série.disponible() fonction. S'il y a de nouvelles données disponibles, le code utilise le En série.parseInt () fonction pour lire l'entrée de l'utilisateur en tant qu'entier.

Le code utilise alors l'instruction IF pour vérifier si l'entrée de l'utilisateur est uniforme ou impair. Il utilise le En série.imprimer() fonction pour imprimer le résultat au moniteur en série.

Enfin, le code imprime un message demandant à l'utilisateur de saisir un autre numéro, et le processus se répète.

Limitations de l'opérateur modulo

Bien que l'opérateur modulo soit un outil utile pour trouver le reste de deux nombres, il a ses limites. L'opérateur modulo ne peut être utilisé qu'avec des valeurs entières. Si vous essayez d'utiliser l'opérateur modulo avec point flottant Nombres, vous rencontrerez une erreur.

Conclusion

Dans la programmation Arduino, l'opérateur de modulo trouve le reste de deux nombres. Il est représenté par le pourcentage de signe (%) et peut être utilisé avec des valeurs entières. L'opérateur modulo peut également vérifier un certain numéro d'entrée si ce numéro d'entrée est uniforme ou impair. Cependant, il ne peut pas être utilisé avec des nombres à virgule flottante. Pour plus de détails sur les opérateurs de modulo à Arduino, lisez l'article.