Chaînes dans Arduino Que sont-elles, à quoi servent-elles et comment les utiliser dans la programmation de projets matériels gratuits?

Les chaînes dans Arduino sont des outils très utiles que vous devez utiliser pour programmer votre carte . Pour cette raison, il est important de savoir à quoi servent ces fonctions et quels types de chaînes vous pouvez trouver.

Pour cela, il est nécessaire que vous lisiez cet article jusqu’au bout car nous vous expliquerons quelles sont les chaînes qui existent et comment est la syntaxe que vous devez utiliser pour comprendre leur travail.

Mais ce n’est pas tout, vous pouvez également trouver un guide pour utiliser correctement une chaîne (objet) et une liste des meilleurs projets que vous pouvez réaliser vous-même.

Qu’est-ce qu’une chaîne dans la programmation Arduino et à quoi servent-elles lors de la programmation de ce type de matériel?

Dans la programmation Arduino , les chaînes sont des outils utilisés pour enregistrer des chaînes de caractères. Par conséquent, une chaîne n’est pas considérée comme une donnée en soi, mais comme une classe dépendante de celles-ci. La fin qu’ils ont est au moyen d’un caractère nul. De plus, ils se caractérisent par la réservation d’une certaine capacité mémoire de la carte Arduino pour créer un buffer et pouvoir utiliser de manière intensive les fonctions qu’ils offrent aux utilisateurs.

Types de chaînes dans la programmation Arduino Que sont tout ce qui existe?

Vous pouvez trouver différents types de chaîne utilisés dans la programmation Arduino.

Nous allons vous montrer chacun d’entre eux ci-dessous:

Char Array

Char Array sont des tableaux de caractères utilisés dans de grandes chaînes de texte . Autrement dit, chaque fois que vous travaillez sur une chaîne avec un langage C ++ qui se termine par la valeur 0 (\ 0), des structures de composition de mémoire consécutives sont créées, occupant ainsi moins de mémoire et sinon une chaîne serait identifiée comme char . Gardez à l’esprit que vous devez toujours terminer par un caractère nul et que vous pouvez faire référence aux caractères individuels de la chaîne.

Objet

En cas de ne pas travailler avec de grandes quantités de textes , un objet String peut être utilisé . Ces classes de données améliorent la gestion des chaînes de caractères grâce à des méthodes utilisées par les utilisateurs pour comparer deux chaînes, rechercher certains caractères, concaténer et ajouter des éléments à la chaîne, entre autres fonctions.

Opérateurs de chaînes

Les opérateurs sont des symboles utilisés pour définir une instruction particulière sur String. De cette façon, vous pouvez établir des actions qui servent à ajouter, extraire et voir si un certain caractère dans la chaîne est vrai ou non.

Syntaxe d’un String (char array) Comment comprendre ses déclarations et ses conditions d’utilisation?

Lorsque vous utilisez une longue chaîne de texte, vous devrez utiliser un tableau de caractères .

Pour ce faire, nous vous montrons comment vous devez le gérer:

Déclarations

Les instructions qui sont valides dans une chaîne pour une chaîne sont:

• char Str1 [14]; Cette syntaxe est utilisée pour démarrer un tableau de manière générale.
• char Str2 [4] = {‘a’, ‘u’, ‘i’}; Dans ce cas, des caractères supplémentaires sont définis, je veux et le compilateur ajoutera le caractère nul.
• char Str3 [4] = {‘a’, ‘u’, ‘i’, ‘\ 0’}; Si vous préférez et souhaitez incorporer le caractère nul manuellement, vous devrez utiliser cette structure.
• char Str4 [] = «ipap»; Vous pouvez initialiser une chaîne avec une constante en utilisant des guillemets simples. L’EDI définira la taille du tableau.
• char Str5 [8] = «ipaparduino»; Si vous définissez la taille manuellement et indiquez une constante, utilisez cette syntaxe.
• char Str6 [15] = «ipaparduino»; Cette structure vous permet d’ajouter une chaîne plus grande, car il reste un espace vide.

Résiliation nulle

Les terminaisons nulles sont utilisées pour définir où se termine une chaîne , pour cela il est nécessaire d’inclure un caractère nul , à partir du code ASCII , à la fin de la fonction. Il peut être inclus manuellement en écrivant «\ 0» ou automatiquement, afin qu’il ait été interprété par l’IDE Arduino .

Tableaux de chaînes

Les tableaux sont utilisés pour configurer des chaînes contenant de grandes quantités de texte . De cette manière, il est possible de travailler plus facilement car la complexité de la manipulation est réduite.

Apprenez étape par étape comment utiliser une chaîne (objet) pour programmer dans Arduino

Pour utiliser une chaîne dans l’IDE, vous devez suivre cette étape par étape:

Syntaxe

La première chose que vous devrez savoir est comment gérer la structure d’une chaîne .

Pour ce faire, vous devrez prendre en compte la syntaxe utilisée dans une chaîne (objet):

• Chaîne (val)
• Chaîne (val, base)
• Chaîne (val, decimalPlaces)

Paramètres

Ensuite, vous allez devoir implémenter les paramètres, qui sont utilisés dans la syntaxe précédente:

• val: fait référence à la variable qui doit être formatée pour obtenir une chaîne. Les données prises en charge dans ces paramètres sont byte, char, double, float, int, long, string, unsigned int et unsigned long.
• base: ce paramètre est facultatif et indique la base dans laquelle la variable doit être formatée. Il est par défaut en base 10, mais peut également être utilisé sur des bases hexadécimales et binaires. Par exemple, String (14, HEX) et String (13, BIN).
• decimalPlaces: lorsqu’une donnée flottante ou double est utilisée comme valeur, la décimale doit être définie.

traits

Enfin, vous devrez incorporer les fonctions à la chaîne.

Les fonctions utilisées dans l’IDE Arduino sont:

• charAt (): cette fonction permet d’accéder à un élément spécifique de la chaîne.
• comparateTo (): avec cet outil vous pouvez comparer deux chaînes et ainsi déterminer si elles sont égales ou non.
• concat (): lorsque vous devez ajouter un élément ou un paramètre à la chaîne, vous devrez utiliser cette fonction.
• c_str (): cette variable est utilisée lorsque vous devez convertir une chaîne en une chaîne de type C.
• endsWith (): utilisé pour vérifier si une certaine chaîne se termine par un caractère spécifique.
• equals (): vous pouvez utiliser cette fonction pour comparer deux chaînes et elles ont trouvé l’égalité.
• equalsIgnoreCase (): comme la fonction précédente, cette variable permet de comparer deux chaînes, mais sans prendre en compte les majuscules et les minuscules.
• getBytes (): permet de copier des caractères à partir d’une chaîne.
• index of (): cette fonction est utilisée sur une chaîne lorsque vous devez rechercher une chaîne ou une valeur dans une chaîne.
• lastIndexOf (): utilisé pour trouver un caractère ou une chaîne.
• lenght (): quand j’ai besoin de connaître la longueur de la chaîne, vous allez devoir utiliser cette fonction.
• remove (): supprime ou modifie des caractères.
• replace (): Vous pouvez remplacer un caractère par un autre dans une chaîne.
• reserve (): vous pouvez utiliser cette fonction pour établir un tampon dans la mémoire de la carte et ainsi pouvoir travailler avec des processus sans affecter les performances du matériel.
• setCharAt (): utilisé pour incorporer un caractère.
• commence par (): cette onction est caractérisée en vérifiant si une chaîne commence par un certain élément.
• substring (): son nom dit tout, cette fonction est utilisée pour obtenir une sous-chaîne dans une chaîne.
• toCharArray (): permet de copier des caractères dans le tampon sélectionné pour avoir un espace en mémoire.
• toDouble (): Si la chaîne est valide, elle peut être utilisée pour la dupliquer.
• toInt (): Une chaîne peut être convertie en entier, tant qu’elle est valide.
• toFloat (): parvient à convertir une chaîne en un caractère flottant.
• toLowerCase (): lorsque la chaîne est écrite en majuscules et qu’il est nécessaire de passer en minuscules, cette fonction doit être utilisée.
• toUpperCase (): est la situation inverse de la fonction précédente.
• trim (): vous pouvez utiliser cet outil pour obtenir un espace blanc au début ou à la fin de la version String.

Liste des meilleurs projets programmés avec Strings que vous pouvez réaliser vous-même

Nous vous montrerons ci-dessous les meilleurs projets que vous pouvez programmer vous-même à l’aide de Strings .

Commençons:

Dispositif de réponse rapide

Avec une carte Arduino UNO , un bouton poussoir, une maquette, un écran led, un jeu de résistances 10k nécessaire à l’installation, vous pouvez créer un écran dans lequel vous entrez une question et recevez une réponse aléatoire. Pour incorporer les questions et réponses, la chaîne doit être utilisée.

Les codes à utiliser:

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

Maintenant, vous devrez inclure les variables et les configurer sur l’affichage à l’écran:

#define SCREEN_WIDTH 128

#define SCREEN_HEIGHT 32

#define STRING_ARRAYSIZE 10

// Déclaration pour un écran SSD1306 connecté à I2C (broches SDA, SCL) - Arduino UNO: A4 (SDA - Data), A5 (SCL - Clock)

#define OLED_RESET 4 // Réinitialiser la broche # (ou -1 si vous partagez la broche de réinitialisation Arduino)

Affichage Adafruit_SSD1306 (SCREEN_WIDTH, SCREEN_HEIGHT, & Wire, OLED_RESET);

Définissez les variables du bouton:

const int buttonPin = 2;

int buttonState = 0;

int lastButtonState = 0;

int randomNumber = 0;

String mainText = "Demander";

void setup () {

// Configuration série

commencer (9600);

// Configuration OLED

// SSD1306_SWITCHCAPVCC = générer une tension d'affichage à partir de 3,3 V en interne

if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adresse 0x3C pour 128x32

println (F ("Échec de l'allocation SSD1306"));

pour (;;); // Ne continue pas, boucle pour toujours

}

displayTextOnOLED (mainText);

// PIN dédié à la configuration des boutons

pinMode (buttonPin, INPUT);

// si la broche d'entrée analogique 0 n'est pas connectée, analogique aléatoire

// le bruit provoquera la génération de l'appel à randomSeed ()

// numéros de départ différents à chaque exécution de l'esquisse.

// randomSeed () mélangera alors la fonction aléatoire.

randomSeed (analogRead (0));

}

// le but est d'écouter l'état du bouton

// et lorsque vous appuyez sur l'OLED pour afficher un texte différent

// lorsqu'il est relâché pour afficher le texte setup ()

boucle void () {

// lit l'état de la valeur du bouton poussoir:

buttonState = digitalRead (buttonPin);

if (buttonState! = lastButtonState) {

if (buttonState == HIGH) {

displayTextOnOLED (randomText ());

} autre {

displayTextOnOLED (mainText);

}

}

lastButtonState = buttonState;

}

void displayTextOnOLED (chaîne de caractères) {

clearDisplay ();

setTextSize (2); // Dessine du texte à l'échelle 2X

setTextColor (SSD1306_WHITE);

setCursor (0,0);

println (str);

afficher (); // Afficher le texte initial

}

Utilisez la chaîne:

String randomText (void) {

Textes de chaîne [STRING_ARRAYSIZE] = {"Da", "Nu", "Nu stiu!", "Nu vreau!", "Du-te naibii!", "Varule", "Te pup!", "Sigur!", "Sigur ca nu!", "Nah!"};

if (buttonState! = lastButtonState) {

randomNumber = aléatoire (1, 10);

textes de retour [randomNumber];

} autre {

textes de retour [randomNumber];

}

}

Station radar

Dans ce projet, vous aurez besoin d’une carte Arduino , d’un capteur à ultrasons HC-SR04, d’ un servomoteur, de câbles et d’une résistance de 10k. Vous devrez connecter le capteur aux broches 10 et 11 de la carte, puis le servo à la broche numéro 12.

Ensuite, vous devrez entrer ces codes en utilisant des chaînes:

#include <Servo.h>.

const int trigPin = 10;

const int echoPin = 11;

longue durée;

distance int;

Pour contrôler le servomoteur, vous devrez créer un objet servo:

MyServo Servo;

void setup () {

pinMode (trigPin, OUTPUT);

PinMode de sortie (echoPin, INPUT);

commencer (9600);

attacher (12);

}

boucle void () {

Réglez le rayon de braquage du servomoteur entre 15 et 165 degrés:

pour (int i = 15; i <= 165; i ++) {

écrire (i);

retard (30);

distance = calculerDistance ();

imprimer (i);

impression (",");

impression (distance);

impression (".");

}

pour (int i = 165; i> 15; i -) {

écris moi);

retard (30);

distance = calculerDistance ();

imprimer (i);

impression (",");

impression (distance);

impression (".");

}

}

int CalculateDistance () {

digitalWrite (trigPin, LOW);

delayMicrosecondes (2);

digitalWrite (trigPin, HIGH);

delayMicrosecondes (10);

digitalWrite (trigPin, LOW);

durée = pulseIn (echoPin, HIGH);

distance = durée * 0,034 / 2;

distance de retour;

}

Utilisez SerialEvent () pour recevoir les valeurs de distance et d'angle:

vide drawRadar () {

pushMatrix ();

traduire (960,1000);

aucun remplissage ();

strokeWeight (2);

accident vasculaire cérébral (98,245,31);

arc d'arc (0,0,1800,1800, PI, TWO_PI);

arc (0,0,1400,1400, PI, TWO_PI);

arc (0,0,1000,1000, PI, TWO_PI);

arc (0,0,600,600, PI, TWO_PI);

ligne des lignes angulaires (-960,0,960,0);

ligne (0,0, -960 cos (radians (30)), - 960 sin (radians (30)));

ligne (0,0, -960 cos (radians (60)), - 960 sin (radians (60)));

ligne (0,0, -960 cos (radians (90)), - 960 sin (radians (90)));

ligne (0,0, -960 cos (radians (120)), - 960sin (radians (120)));

ligne (0,0, -960 cos (radians (150)), - 960 sin (radians (150)));

ligne (-960 * cos (radians (30)), 0.960.0);

popMatrix ();

}

Tracez les lignes qui seront vues sur le radar:

vide drawLine () {

pushMatrix ();

strokeWeight (9);

accident vasculaire cérébral (30, 250, 60);

traduire (960,1000);

ligne de localisation (0,0,950 cos (radians (iAngle)), - 950 sin (radians (iAngle)));

popMatrix ();

}

Écran d'impression radar 04

Maintenant, vous allez devoir dessiner les objets que le radar détecte:

vide drawObject () {

pushMatrix ();

traduire (960,1000);

strokeWeight (9);

accident vasculaire cérébral (255, 10, 10);

pixsDistance = iDistance 22,5;

si (iDistance <40) {

// dessine l'objet selon l'angle et

ligne de distance (pixsDistance cos (radians (iAngle)), -pixsDistance sin (radians (iAngle)), 950 cos (radians (iAngle)), - 950 * sin (radians (iAngle)));

}

popMatrix ();

}

Ajoutez des mots à l’écran:

tirage vide () {

remplissage (98 245,31);

textFont (orcFont);

noStroke ();

remplissage (0,4);

rect (0, 0, largeur, 1010);

remplissage (98 245,31); // couleur verte

drawRadar ();

Dessiner une ligne();

drawObject ();

drawText ();

}

Faites la programmation du radar:

import processing.series. *;



import java.awt.event.KeyEvent;



import java.io.IOException;



Serial myPort;



Angle de chaîne = "";