Comment combiner des variables de chaîne Croquis Arduino. Basé sur « Traitement des chaînes sur Arduino ». Guillemets simples ou doubles

23.04.2019

Peu importe combien j’étudie Arduino, il ne cesse de m’étonner par sa simplicité. Par exemple, lors de l'assemblage et du test du système "maison intelligente", j'ai pensé que l'envoi de commandes depuis l'ordinateur serait la partie la plus difficile - vous devez recevoir une ligne du port série, la reconnaître et vous assurer qu'aucune erreur ne se produit. .. Cependant, il s'est avéré suffisant de lire le site Web Arduino.cc et de tester quelques exemples, comme il est devenu clair : les développeurs ont essayé de nous protéger contre l'écriture de code long et ennuyeux. D’ailleurs, j’ai finalement terminé la tâche dans la soirée, à la fin j’ai même pensé : « quelle autre commande pourrais-je ajouter ?.. »

Supposons donc que vous sachiez déjà programmer Arduino et que vous puissiez comprendre votre propre code ou celui de quelqu'un d'autre. L'un des concepts de base concerne les variables et leurs types. Eh bien, désinvolte ? byte, int, long, char, string... Les deux derniers sont essentiellement la même chose, car string est un tableau de variables de type char (quelqu'un devrait maintenant objecter que char est représenté comme un nombre d'octets, mais ce n'est pas le cas). indiquer ). Ainsi, tout ce qui est reçu du port série doit être lu comme char :

Char inChar = " "; octet z = 0 ; while (Serial.available()) ( inChar[z] = Serial.read(); z++; )

C'est le premier exemple qui pourrait venir à l'esprit. Nous créons une ligne vide, puis, s'il y a quelque chose à lire sur le port série, nous le remplissons caractère par caractère. La fonction Serial.available() renvoie le nombre d'octets disponibles en lecture, et s'il est vide, alors 0, évidemment. Cela peut être utilisé pour connaître la longueur de la commande donnée, même si nous la connaissons déjà dans l'exemple donné - c'est la valeur de la variable z à la sortie de la boucle. Oui, une chaîne d'espaces (code ASCII pour un espace - pas zéro !) est tolérable, mais ce n'est toujours pas très bon, évitez-le si possible. Et le lecteur à l'esprit vif pourra se féliciter s'il devine immédiatement ce qui doit être corrigé dans le code ci-dessus. Pour ceux qui n'ont pas deviné, un indice : char inchar est une chaîne de 6 caractères. Si une chaîne reçoit une valeur, le compilateur permet que sa longueur ne soit pas spécifiée explicitement, donc les crochets dans l'exemple sont vides.

Au fait, n'oubliez pas d'écrire dans setup()

Série.begin(9600);

Et dans le moniteur de port intégré, auquel les commandes seront effectivement envoyées, spécifiez la vitesse - 9600 bauds, sinon vous verrez des fissures.

Ensuite, que faire de la chaîne résultante ? Ceux qui proposent de comparer une chaîne octet par octet avec des valeurs connues (et une telle idée peut certainement venir à l'esprit de quelqu'un) après avoir lu l'article avanceront dans le temps de 20 ans par rapport au passé, je veux dire :)

Une recherche dans la documentation de l'IDE Arduino donne deux options pour savoir ce qu'est une chaîne. Il s'agit d'une chaîne elle-même en tant que chaîne de caractères, et String, qui est un objet. Selon Wikipédia, il s'agit d'une « entité dans l'espace virtuel qui a un certain état et un certain comportement, qui a des valeurs de propriétés spécifiées ». (attributs) et opérations sur eux (méthodes) ". En d'autres termes, une variable avec des fonctions intégrées qui font quelque chose avec cette variable. Pour commencer à travailler avec cet objet, écrivons quelque chose comme ceci :

Entrée de chaîne = "" ; while (Serial.available()) ( input += Serial.read(); )

Ici, de plus en plus de nouveaux caractères seront ajoutés à l'entrée jusqu'à ce que le tampon soit épuisé. Il sera alors possible d'analyser la chaîne résultante, par exemple, comme ceci :

Entrée.toLowerCase(); if(input.startsWith("pause")) ( String toWait = input.substring(5); toWait.trim(); int delaytime = toWait.toInt(); if(delaytime>0) ( if(delaytime<10000) { delay(delaytime); } } }

Le code utilise des fonctions très pratiques intégrées à l'objet String. Il s'agit de startWith(), qui renvoie un si la chaîne commence par ce qui est écrit entre parenthèses, substring(), qui renvoie un morceau de chaîne, en commençant dans ce cas par le 5ème caractère (compté à partir de zéro), trim() , qui supprime tout ce qui est inutile se trouve sur les bords de la ligne, et toInt(), qui transforme ce qui reste en un certain nombre de type Int. C’est également une bonne idée de vérifier ce nombre pour voir s’il se situe dans la fourchette attendue. En conséquence, si vous donnez la commande « PauSe 567 », alors le MK attendra exactement 567 millisecondes.

Cela vaut la peine d'écrire sur trim() séparément. Il est nécessaire non seulement de supprimer l'espace au début de la ligne résultante, mais surtout de supprimer les caractères à la fin. Ce sont des caractères de service ajoutés lors de l'envoi d'un message - NL (nouvelle ligne) et CR (retour chariot). Ils sont nécessaires uniquement pour signaler la fin de la commande, mais ils peuvent aussi interférer. Par conséquent, même si le moniteur de port peut choisir lequel de ces caractères envoyer ou rien à envoyer, il est préférable d'être prudent. De plus, cela se fait en une seule ligne de code.

Et voici la liste des fonctions (méthodes) de l'objet String.

charAt()- renvoie le caractère à la position spécifiée

concaténer()- fonction de concaténation, c'est-à-dire fusionner deux chaînes en une seule. Certes, string1 = string1 + string2 est identique à string1.concat(string1, string2), mais est écrit plus simplement et plus clairement.

est égal()- en renvoie un si la chaîne est égale, caractère par caractère, à ce qui est écrit entre parenthèses. Il existe également equalsIgnoreCase(), qui ignore la casse (majuscule ou inférieure)

se termine par()- qui fonctionne de la même manière que startWith()

indexDe()- renvoyer l'emplacement dans la chaîne du caractère (ou de la chaîne) entre parenthèses. Recherche à partir de la fin et renvoie -1 s'il n'est pas trouvé.

longueur()- afficher la longueur de la chaîne

setCharAt()- exigeant une place et un caractère qui doit être placé à cette place, par exemple : string1.setCharAt(3, "d") mettra d comme troisième caractère de la ligne à la place de ce qu'il y avait

Et quelques autres dont vous n'aurez probablement pas besoin si vous ne pouvez pas aller sur arduino.cc et en savoir plus :)

C'est tout ce que je voulais te dire. J'espère que cet article vous aidera à ne pas avoir peur de la POO et à apprendre à votre robot domestique sur Arduino à obéir aux signaux de l'ordinateur

Les chaînes de texte peuvent être déclarées de deux manières : vous pouvez utiliser le type de données String, qui est inclus dans le noyau depuis la version 0019 ; ou déclarez la chaîne comme un tableau de caractères terminé par un caractère nul. Cette page décrit la deuxième méthode. Pour plus d'informations sur l'objet String, qui fournit davantage de fonctionnalités au prix de plus de mémoire, consultez la page Objet String.

Exemples

Vous trouverez ci-dessous des exemples de déclarations de chaîne correctes.

Caractère Str1 ;

char Str2 = ("a", "r", "d", "u", "i", "n", "o");

char Str3 = ("a", "r", "d", "u", "i", "n", "o", "\0");
char Str4 = "arduino";
char Str5 = "arduino";
char Str6 = "arduino";
Opérations autorisées lors de la déclaration de chaînes
Déclarer un tableau de caractères sans l'initialiser (Str1)

Déclarez un tableau de caractères avec un élément redondant, le compilateur lui-même ajoutera le caractère nul requis (Str2)

En règle générale, toutes les chaînes se terminent par un caractère nul (code ASCII 0), qui permet aux fonctions (comme Serial.print()) de déterminer la longueur de la chaîne. Sans ce symbole, ils continueraient à lire séquentiellement des octets de mémoire qui ne feraient plus réellement partie de la chaîne.

Essentiellement, cela signifie que la longueur de votre chaîne doit être supérieure d'un caractère à celle du texte que vous souhaitez y stocker. C'est pourquoi Str2 et Str5 doivent comporter 8 caractères, même si le mot "arduino" n'en occupe que 7 - la dernière position est automatiquement remplie par un caractère nul. La taille de Str4 deviendra automatiquement 8 - un caractère requis pour le null final. Dans la chaîne Str3, nous avons nous-mêmes spécifié le caractère nul (noté "\0").

Notez qu'il est généralement possible de déclarer une chaîne sans caractère nul final (par exemple, si vous définissez la longueur de Str2 sur 7 plutôt que 8). Cependant, cela brisera la plupart des fonctions de chaîne, vous ne devriez donc pas le faire intentionnellement. Cette erreur peut provoquer un comportement étrange ou l'apparition de caractères étrangers lors de l'utilisation de chaînes.

Guillemets simples ou doubles ?

Les chaînes sont toujours déclarées entre guillemets doubles ("Abc") et les caractères sont toujours déclarés entre guillemets simples ("A").

Envelopper de longues lignes

Les longues lignes peuvent être enroulées comme ceci :

Char myString = "Ceci est la première ligne" " ceci est la deuxième ligne" " etcetera";

Tableaux de chaînes

Lorsque vous travaillez avec de grandes quantités de texte (par exemple, dans des projets fonctionnant avec un écran LCD), il est souvent pratique d'utiliser des tableaux de chaînes. Puisque les chaînes sont elles-mêmes des tableaux, il s’agit en fait d’un exemple de tableau à deux dimensions.

Dans le programme suivant, l'astérisque après le type de données char "char*" indique que la variable est un tableau de "pointeurs". Tous les noms de tableaux sont en fait des pointeurs, l'astérisque est donc nécessaire pour créer un tableau de tableaux. Les pointeurs en C sont l’une des choses les plus difficiles pour les débutants, mais dans ce cas, une compréhension approfondie des pointeurs n’est pas nécessaire pour les utiliser efficacement.

Exemple

char* myStrings=("Ceci est la chaîne 1", "Ceci est la chaîne 2", "Ceci est la chaîne 3", "Ceci est la chaîne 4", "Ceci est la chaîne 5", "Ceci est la chaîne 6"); void setup())( Serial.begin(9600); ) void loop())( for (int i = 0; i< 6; i++){ Serial.println(myStrings[i]); delay(500); } }

Que fallait-il ? Affichage des informations et des chaînes de traitement saisies par l'utilisateur. Par exemple:

Contrôleur Ethernet - ok
Mode STATIQUE
>temps
2015-11-16 22:35:27

En fait, il faut comparer les drains. Non, vous devez d'abord diviser le texte en fragments avec un séparateur (par exemple, un espace), mais ensuite comparer les lignes. Comme les commandes étaient "un, deux - et c'était mal calculé", j'ai supprimé la décomposition du texte en fragments. En raison de l’erreur ci-dessus, la classe String n’a pas pu être utilisée, comment procéder différemment ? Arduino utilise la bibliothèque AVR-libc, il est donc logique de s'y tourner en premier.
Qu'avons-nous ?

stdlib.h - fonctions de conversion mutuelle de nombres et de chaînes (dans les deux sens).
string.h - fonctions pour travailler avec des chaînes. Notre principal intérêt.
stdio.h - fonctions d'entrée/sortie standard.

La fonctionnalité ne se limite pas à cela. Quelque chose en rapport avec la tâche est mentionné.

N°2 - utiliser les fonctions ensemble de mémoires pour remplir ou vider le tampon, memcmp- à titre de comparaison. strcmp Je ne l'utilise pas car je dois explicitement limiter la longueur du fragment comparé. N°3 - pour la lecture et la sortie du format : sprintf, sprint_P, scanf, sscanf_P. Fonctions avec suffixe _P diffèrent en ce que la chaîne de format est extraite de la mémoire du programme PROGMEM, également appelée macro. F() dans les bibliothèques Arduino.

D'ailleurs

À propos, si vous implémentez pleinement les fonctions d'entrée-sortie d'un seul caractère obtenirc Et putc, vous obtiendrez alors des flux d'entrée, de sortie, d'erreur et de fichiers standard, si vous en avez. Vous pouvez souvent vous en sortir en remplaçant les macros putchar() Et getchar(), fonctionnant avec une entrée et une sortie standard.

Ma comparaison de chaînes ressemble à ceci :

If (memcmp(str ,"statlist" ,8)==0) ( // votre code ici )

Il convient peut-être de mentionner que les débuts des lignes sont comparés. Pour rechercher des fragments, vous pouvez utiliser memmem.

chaînes pour C

chaînes pour C str, ils sont caractère *- ceci est un lien vers le début de la séquence carboniser, dont le dernier compte 0x00. Cela signifie qu'ils doivent être placés quelque part. Par exemple, dans un tableau. Ou utiliser malloc, calloc, gratuit. Ce qui vous empêche de faire des erreurs signifie transférer la responsabilité au programmeur pour leur placement et leur contrôle de longueur.

Autrement dit, la recherche d'une commande pourrait ressembler à ceci :

Si (memcmp(str ,"statclear", 9)==0) ( memset(journal, 0, sizeof(jrn_rec_t)*JRN_REC_NUM); Serial.println(F("ok")); )else if (memcmp(str ,"statlist" ,8)==0) ( funcStatlist(); )else if (memcmp(str , "cfgshow", 7)==0) ( funcCfgShow(); )else if (memcmp(str , "timeset" , 7)==0) ( funcTimeSet(str); // date et heure de configuration AAAA-MM-JJ hh:mm:ss )else if (memcmp(str ,"cfgset", 6)==0) ( funcCfgSet( str); //funcPingdel(str); else if (memcmp(str ,"time", 4)==0) ( funcTime(); // affiche la date et l'heure à partir de RTC )else if (memcmp(str ," help", 4)==0) ( // imprimer une aide courte Serial.println(F(" helprn statlist statclearrn time timesetrn cfgshow cfgset")); )else( Serial.print(F("unknow cmd> ")); Serial.println(str);

Moment non évident

Les commandes, ou lignes, de plus grande longueur doivent apparaître en premier dans le fragment ci-dessus. Pensez-y, pourquoi ?

Je « collecte » les lignes de la manière suivante : je lis les octets du port jusqu'à ce que la longueur de ligne autorisée soit dépassée ou jusqu'à ce que l'un des caractères de saut de ligne r ou n soit rencontré.

lire la ligne

Il vaudrait mieux le finaliser... Pour l'instant c'est comme ça. Appelé tout le temps sur le ring principal. S'il n'y a pas de travail, sortez au plus vite et rapportez-le FAUX. Si vous avez tapé une nouvelle ligne - vrai.

bool readln(HardwareSerial &uart, char *outbuf) // renvoie true lors de la recherche de CR, LF ou les deux et si limite de taille ( static char mybuf = ( 0 ); static char idx = 0; while (uart.available()) ( if (uart.peek()!= "r" && uart.peek()!= "n") ( mybuf[ idx++ ] = uart.read(); ) else (// si CR uart.read(); if ( uart.peek()=="n" || uart.peek()=="r") uart.read(); if (idx == 0) ( return 0; ) mybuf[ idx++ ] = ""; add 0 memcpy(outbuf, mybuf, idx); // copie idx = 0; return 1; if (idx >=(SBUF_SZ-1)) ( // vérifie la longueur du tampon interne mybuf[ SBUF_SZ-1 ] = " "; // ajoute 0 memcpy(outbuf, mybuf, 32); // copie idx = 0; return 0;

Le format d'entrée/sortie est également très utile. Par exemple, l'analyse d'une chaîne avec la date et l'heure saisies ressemble à ceci :

Sscanf_P(str, (const char *)F("%*s %d-%d-%d %d:%d:%d"), &y, &m, &d, &hh, &mm, &ss)

Obtenir une chaîne pour afficher l'IP :

Sprintf_P(buff, (const char *)F("Votre IP : %d.%d.%d.%d"), ip, ip, ip, ip); C'est tout. J'espère que ce matériel aidera quelqu'un à « se débarrasser » d'Arduino ou simplement à écrire ses programmes mieux et en moins de temps. Mais une situation plus typique consiste à contourner les restrictions.

Arduino String est la bibliothèque principale pour travailler avec des chaînes dans Arduino. Cela simplifie grandement l’utilisation de tableaux de caractères et de chaînes dans une esquisse. L'objet String contient de nombreuses fonctions utiles pour créer et concaténer des chaînes, des conversions de chaîne en entier (analyse de nombres) et de entier en chaîne (formatage de nombres). Les chaînes sont utilisées dans presque tous les projets, la probabilité de rencontrer String dans une esquisse est donc très élevée. Dans cet article nous tenterons de considérer les principales méthodes de cette classe et les situations les plus fréquemment rencontrées.

La manière standard de travailler avec des chaînes en C consiste à utiliser un tableau de caractères. Tout cela signifiait la nécessité de travailler avec des pointeurs et de comprendre l’arithmétique des adresses. En Arduino et C++, les programmeurs ont beaucoup plus de possibilités. Toutes les opérations de « bas niveau » permettant de travailler avec une chaîne sont séparées dans une classe distincte et les opérateurs sont même redéfinis pour les opérations de base. Par exemple, pour combiner un terme, nous utilisons simplement le signe familier « + », plutôt que des fonctions écrasantes comme malloc et strcpy. Avec String, nous traitons la chaîne comme un objet entier plutôt que comme un tableau de caractères. Cela vous permet de vous concentrer sur la logique de l'esquisse plutôt que sur les détails de mise en œuvre du stockage des symboles en mémoire.

Naturellement, toute « simplification » comporte toujours ses pièges. String utilise toujours plus de RAM et, dans certains cas, les fonctions de classe peuvent être plus lentes à traiter. Par conséquent, dans les vrais grands projets, nous devrons peser soigneusement le pour et le contre et ne pas oublier que personne ne nous empêche de travailler avec des chaînes de style C. Toutes les fonctions habituelles de traitement des tableaux de caractères restent dans notre arsenal dans Arduino.

Créer des chaînes dans Arduino à l'aide de String

Dans Arduino, nous avons plusieurs façons de créer une chaîne, voici les principales :

char myCharStr = « Démarrer » ; – un tableau de type char avec un caractère vide final ;
Chaîne myStr = « Démarrer » ; – déclarer une variable, créer une instance de la classe String et y écrire une constante chaîne.
String myStr = String("Démarrer"); – similaire au précédent : créer une chaîne à partir d’une constante
Chaîne maStr(myCharStr); – créez un objet de la classe String en utilisant un constructeur qui prend un tableau de type char en entrée et crée une chaîne à partir du char.
Chaîne maStr = Chaîne (50); – créer une chaîne à partir d’un entier (conversion int en chaîne).
Chaîne maStr = Chaîne(30, H); – créer une chaîne – représentation d'un nombre dans le système à 16 chiffres (HEX vers String)
Chaîne maStr = Chaîne (16, B); – créer une chaîne – une représentation d'un nombre dans le système binaire (Byte to String).

Chaque fois que nous déclarons une chaîne en utilisant des guillemets doubles dans le code, nous créons un objet String implicite qui est une constante. Dans ce cas, il est nécessaire d'utiliser des guillemets doubles : « String » est une chaîne. Les guillemets simples sont utilisés pour représenter des caractères individuels. « S » est un symbole.

Fonctions et méthodes de la classe String

String possède de nombreuses fonctions utiles pour travailler avec des chaînes. Voici une brève description de chacun d’eux :

Chaîne()– constructeur, crée un élément de la classe de données chaîne. Il n'y a pas de valeur de retour. Il existe de nombreuses options qui vous permettent de créer une chaîne à partir de chaînes, de caractères et d'un certain nombre de formats différents.
charAt() renvoie l'élément spécifié dans la chaîne. La valeur de retour est le nième caractère de la chaîne.
comparerÀ()– la fonction est nécessaire pour vérifier l’égalité de deux chaînes et vous permet de déterminer laquelle d’entre elles vient en premier dans l’alphabet. Valeurs de retour : nombre négatif si la ligne 1 précède la ligne 2 par ordre alphabétique ; 0 – si deux chaînes sont équivalentes ; un nombre positif si la deuxième ligne précède la première par ordre alphabétique.
concaténer()– une fonction qui combine deux chaînes en une seule. Le résultat de l’ajout de chaînes est combiné dans un nouvel objet String.
commenceAvec()– la fonction indique si la ligne commence par le caractère spécifié dans la deuxième ligne. Valeur de retour : true si la ligne commence par un caractère de la deuxième ligne, false sinon.
se termine par()– fonctionne de la même manière que startWith(), mais vérifie la fin de la ligne. Renvoie également vrai et faux.
est égal()– compare deux chaînes en respectant la casse, c'est-à-dire les chaînes "start" et "START" ne seront pas considérées comme équivalentes. Valeurs de retour : vrai si équivalent, faux sinon.
est égal à IgnoreCase()– similaire à égal, mais cette fonction n'est pas sensible à la casse.
getBytes()– vous permet de copier les caractères de la chaîne spécifiée dans le tampon.
indexDe()– recherche un caractère dans une chaîne depuis le début. Renvoie la valeur d'index de la sous-chaîne val ou -1 si la sous-chaîne n'est pas trouvée.
dernierIndexOf()– recherche un caractère dans une chaîne à partir de la fin.
longueur()– spécifie la longueur de la chaîne en caractères, à l'exclusion du caractère nul de fin.
remplacer()– remplace les occurrences d'un caractère spécifique dans une chaîne par une autre.
setCharAt()– modifie le caractère souhaité dans la chaîne.
sous-chaîne()– renvoie une sous-chaîne. Peut prendre deux valeurs – index de début et de fin. Le premier est inclusif, c'est-à-dire l'élément qui lui correspond sera inclus dans la ligne, le second non.
versCharArray()– copie les éléments d'une chaîne dans le tampon.
versMinuscule()– renvoie une chaîne écrite en minuscules.
versUpperCase()– renvoie une chaîne écrite en majuscule.
versInt()– permet de convertir une chaîne en nombre (entier). S'il y a des valeurs non entières dans la chaîne, la fonction abandonne la conversion.
garniture()– supprime les espaces inutiles au début et à la fin de la ligne.

Concaténation de chaînes Arduino

Vous pouvez combiner deux chaînes en une seule de différentes manières. Cette opération est aussi appelée concaténation. Le résultat est un nouvel objet String composé de deux chaînes concaténées. Vous pouvez ajouter différents symboles à une chaîne :

Chaîne3 = chaîne1 + 111 ; // permet d'ajouter une constante numérique à une chaîne. Le nombre doit être un entier.
Chaîne3 = chaîne1 + 111111111 ; // ajoute un entier long à la chaîne
Chaîne3 = chaîne1 + 'A' ; // ajoute un caractère à la chaîne
String3 = string1 + « aaa » ; // ajoute une constante de chaîne.
Chaîne3 = chaîne1 + chaîne2 ; // concatène deux chaînes ensemble.

Il est important d'être prudent lors de la concaténation de deux chaînes de types de données différents, car cela peut entraîner une erreur ou un résultat incorrect.

Chaîne Arduino à int et chaîne à flotter

Pour convertir des valeurs entières chaîne en entier La fonction toInt() est utilisée.

Chaîne MyStr = « 111 » ;

int x = MyStr.toInt();

Si vous devez convertir un objet à virgule flottante, utilisez la fonction atof().

Chaîne MyStr = « 11.111 » ;

MyStr.toCharArray(myStr1, MyStr.length()); // La chaîne est copiée dans le tableau myStr1

float x = atof(myStr1); // conversion en flottant

Convertir un entier en chaîne

Pour créer une chaîne à partir d'un nombre, vous n'avez pas besoin d'effectuer de mouvements particuliers. On peut simplement concaténer une chaîne et un nombre :

String str = « Numéro de ligne « + i ;

Nous pouvons créer un objet en utilisant le constructeur

Chaîne str = Chaîne (50);

Nous pouvons combiner les deux méthodes :

String str = « Numéro de chaîne « + String(50) ;

Conversion d'une chaîne en tableau de caractères

Le type de données Char vous permet de déclarer des chaînes de texte de plusieurs manières :

char maStr1; – dans ce cas, un tableau d'une certaine taille est déclaré.
char myStr2 = ('a', b, 'c', 'd', 'e'); – le tableau lui-même est déclaré. Le caractère de fin n'est pas écrit explicitement ; le compilateur lui-même l'ajoute.
char myStr3 = ('a', b, 'c', 'd', 'e'/0'); – un tableau est déclaré, avec un signe de fin de ligne écrit à la fin.
char maStr4 = « abcde » ; – initialisation d'un tableau de constantes de chaîne. La taille et le caractère de fin sont ajoutés automatiquement par le compilateur.
char maStr5 = « abcde » ; – initialisation du tableau avec indication exacte de sa taille.
char maStr 6 = « abcde » ; – similaire, mais la taille est plus grande pour permettre l’utilisation de lignes plus longues.

Rappelons encore une fois que dans le type de données char, les constantes chaîne doivent être écrites entre guillemets doubles « Abcde » et les caractères simples entre guillemets simples « a ».

Convertir chaîne en tableau tableau de caractères vous pouvez utiliser le code suivant :

Chaîne chaîneVar = « 111 » ;

char charBufVar;

stringVar.toCharArray(charBufVar, 20);

Vous pouvez faire la transformation inverse - caractère en chaîne.

char chArray = « début » ;

Chaîne str(chArray);

Exemple de conversion Chaîne en caractère const*. L'astérisque char* signifie qu'il s'agit d'un tableau de pointeurs.

String stringVar=string(`start);

Char charVar[ taillede ;

stringVar.toCharArray(charVar, sizeof(charVar));

Conclusion sur String et Arduino

Dans cet article, nous avons examiné les bases de l'utilisation de String pour travailler avec les chaînes Arduino. Comme le montrent les exemples, il n’y a rien d’effrayant ou de difficile dans ce cours. De plus, souvent, nous ne réalisons même pas que nous travaillons avec la classe String : nous créons simplement une variable du type souhaité et lui attribuons une chaîne entre guillemets doubles. Après avoir créé une chaîne, nous utilisons toutes les capacités de la bibliothèque String : nous pouvons facilement modifier une chaîne, concaténer des chaînes, convertir une chaîne en int et inversement, et également effectuer de nombreuses autres opérations à l'aide de méthodes de classe.

Dans les situations où le croquis est volumineux et que nous sommes confrontés à un manque de mémoire, nous devons utiliser String avec précaution, en le remplaçant par char* si possible. Cependant, dans la plupart des premiers projets d'un développeur Arduino novice, il n'y a pas beaucoup de telles situations, nous vous recommandons donc d'utiliser String sans crainte - cela évitera les erreurs arithmétiques d'adresse qui surviennent lors de l'utilisation de tableaux de caractères.

Je suis arrivé à la programmation en général, et à la programmation Arduino en particulier, comme un zéro complet, il y a environ deux mois. Désormais, dans le cadre de mes activités actuelles, j'ai ressenti le besoin de maîtriser le traitement des chaînes sur Arduino. Un simple voyage d'information sur Google ne m'a pas plu avec un article où tout est écrit simplement et clairement pour les nuls. Et c’est pourquoi je suis ici pour parler de la façon dont l’analyse des chaînes à partir d’un port série a été implémentée et des pièges rencontrés en cours de route. Pour ceux que cela intéresse, merci de vous référer au chat.

Donc. Voici un exemple d'algorithme que j'ai suivi :

Nous allons sur arduino.ru et cherchons dans la colonne type tout ce qui concerne les symboles.
Nous décidons quelle forme de représentation nous utiliserons (j'ai opté pour la classe String car j'ai eu une expérience désagréable avec un tableau désordonné).
Nous essayons frénétiquement d'écrire notre propre fonction avec des préférences et des grilles professionnelles
Je recherche un cours.
Nous recherchons les opérateurs nécessaires.
Écrivons!

Et l'algorithme du corps principal du programme est simple :

Nous vérifions cycliquement s'il y a un octet lisible dans le tampon du port com ; s'il y en a, nous le lisons.
Si l'octet reçu est un caractère de saut de ligne ("n"), alors nous appelons la fonction d'analyse auto-écrite, sinon, nous ajoutons l'octet reçu à la variable de type String créée.

Enfin, analysez la chaîne.

En fait, parce que Étant donné que l'utilisation pratique de l'analyse de chaînes ne fonctionne pas pour moi, cette fonction n'est que de nature démonstrative, comparant la chaîne résultante avec une chaîne constante déjà écrite en mémoire. Ainsi, en utilisant l'opérateur égal, nous comparons la chaîne reçue avec celle écrite, et si l'opérateur renvoie vrai, nous quittons la fonction gestionnaire sinon, nous la comparons avec la suivante ; Si les chaînes sont équivalentes, là encore, nous quittons la fonction de gestionnaire et renvoyons le résultat. Eh bien, si cette condition ne fonctionne pas, nous quitterons toujours la fonction et dirons que la ligne n'est pas vraie.

En fonction du résultat accepté, utilisez switch case pour sélectionner celui souhaité.
Nous réinitialisons la chaîne reçue afin de pouvoir recommencer à la collecter.

Et pour finir, voici le code :

#define led 13 String input_string = ""; const String Led_off = "éteindre la LED"; const String Led_on = "allumer la LED"; bool led_running; void setup() ( Serial.begin(9600); ) void loop() ( while (Serial.available() > 0) ( char c = Serial.read(); if (c == "n") ( Serial. print("Input_string is: "); Serial.println(input_string); switch (parse(input_string, Led_off, Led_on)) ( case 10: led_running=false; Serial.println("La mise hors tension est terminée"); break; case 11 : led_running=true; Serial.println("La mise sous tension est terminée"); break; case 0: Serial.println("invalid String"); parse(String input_string, const String Led_off, const String Led_on) ( if (input_string.equals(Led_off) == true) ( return 10; ) else if (input_string.equals(Led_on) == true) ( return 11; ) sinon renvoie 0 ;

Alors, je ne comprends pas ce qui se passe ? Pourquoi la LED ne s'allume-t-elle pas ? Oh oui, comment ai-je oublié ça, dans la configuration vide, vous devez ajouter :

PinMode (led, SORTIE);

P.S. : Il est important de régler le moniteur du port COM dans l'IDE Arduino sur le mode « Nouvelle ligne », car dans tous les autres cas, la chaîne envoyée ne sera pas suivie de son caractère final "n".

P.P.S. : Je ne vais pas participer au holivar sur le fait qu'Arduino n'est pas nécessaire ; je n'ai rien fait de mal en étudiant les bases de la programmation et de l'algorithmique.

P.P.P.S. : Si l'article est reçu de manière adéquate, j'écrirai le suivant sur ce que j'ai fait pour améliorer la fonctionnalité de la fonction d'analyse. Eh bien, avec Dieu ! .