Continuamos com esta série iniciada no MIC176. Nesta segunda parte deste artigo, veremos como usar operadores para comparar strings, verificar quantos caracteres uma string possui e como remover espaços em branco. Parte 1 em MIC176.
MIC031S
OPERADORES PARA COMPARAÇÃO DE STRINGS.
Para comparar 2 strings e verificar se elas são iguais, você pode usar o operador '=='. A comparação é sensível a maiúsculas e minúsculas(diferencia maiúsculas de minúsculas), o que significa que a String "hello" não é igual a "HELLO". Para saber se as strings são diferentes, podemos usar o operador '! ='. Também é possível saber se uma string é maior ou menor que outra string. Para isso, podemos usar os operadores '>' e '<'.
Esses operadores trabalham com base na posição que os caracteres ocupam no conjunto de caracteres ASCII. Para comparar string, também podemos usar a função equals(). No programa a seguir, vários desses operadores são usados e podem ser encontrados no menu: File-> Examples-> Strings-> StringComparisonOperators. O fluxograma pode ser visto na Figura 1.
String stringOne, stringTwo; void setup() { // Abra a comunicação serial e espere a porta abrir: Serial.begin(9600); while(!Serial) { ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa } stringOne = String("this"); stringTwo = String("that"); // envie uma introdução: Serial.println("\n \nComparando Strings:"); Serial.println(); } void loop() { // duas strings iguais: if(stringOne == "this") { Serial.println("StringOne == \"this\""); } // duas Strings não iguais: if(stringOne! = stringTwo) { Serial.println(stringOne + "=!" + StringTwo); } // duas Strings não iguais(questões de maiúsculas e minúsculas): stringOne = "This"; stringTwo = "this"; if(stringOne != stringTwo) { Serial.println(stringOne + "=!" + StringTwo); } // você também pode usar equals() para ver se duas Strings são as mesmas: if(stringOne.equals(stringTwo)) { Serial.println(stringOne + " igual a “ + stringTwo); } else { Serial.println(stringOne + " não é igual a " + stringTwo); } // ou talvez você queira ignorar o caso: if(stringOne.equalsIgnoreCase(stringTwo)) { Serial.println(stringOne + " igual a(ignorando o caso) " + stringTwo); } else { Serial.println(stringOne + " não é igual(ignorando o caso) " + stringTwo); } // uma string numérica comparada ao número que ela representa: stringOne = "1"; int numberOne = 1; if(stringOne.toInt() == numberOne) { Serial.println(stringOne + " = " + numberOne); } // duas stringss numéricas comparadas: stringOne = "2"; stringTwo = "1"; if(stringOne >= stringTwo) { Serial.println(stringOne + " > = " + stringTwo); } // operadores de comparação podem ser usados para comparar Strings para classificação alfabética também: stringOne = String("Brown"); if(stringOne <"Charles") { Serial.println(stringOne + "<Charles"); } if(stringOne> "Adams") { Serial.println(stringOne + "> Adams"); } if(stringOne <= "Browne") { Serial.println(stringOne + "<= Browne"); } if(stringOne >= "Brow") { Serial.println(stringOne + "> = Brow"); } // o operador compareTo() também permite comparar Strings // avalia no primeiro caracter que é diferente. // se o primeiro caractere da String que você está comparando para vir primeiro // ordem alfanumérica, então compareTo() é maior que 0: stringOne = "Cucumber"; stringTwo = "Cucuracha"; if(stringOne.compareTo(stringDois) <0) { Serial.println(stringOne + " vem antes " + stringTwo); } else { Serial.println(stringOne + " vem depois " + stringTwo); } delay(10000); // porque a próxima parte é um loop: // compareTo() é útil quando você tem Strings com números também: while(true) { stringOne = "Sensor:"; stringTwo = "Sensor:"; stringOne += analogRead(A0); stringTwo += analogRead(A5); if(stringOne.compareTo(stringDois) <0) { Serial.println(stringOne + " comes before " + stringTwo); } else { Serial.println(stringOne + " comes after ” + stringTwo); } } }
CRIANDO OU CONSTRUINDO STRINGS.
Existem várias maneiras de criar ou criar strings em um programa. A lista a seguir mostra alguns deles:
String stringOne = "Hello String"; // usando uma string constante.
String stringOne = String('a'); // convertendo um char constante em uma String.
String stringTwo = String("Isto é uma string"); // convertendo uma constante de string // em um objeto String.
String stringOne = String(stringDois + "with more"); // concatenando 2 strings
String stringOne = String(13); // usando uma constante inteira(inteiro)
String stringOne = String(analogRead(0), DEC); // usando um int e uma base
String stringOne = String(45, HEX); // usando um int e uma base(hexadecimal)
String stringOne = String(255, BIN); // usando um int e uma base(binário)
String stringOne = String(millis(), DEC); // usando um long e uma base
String stringOne = String(5,698, 3); // usando um float e casas decimais.
No programa a seguir usamos vários desses construtores para criar strings. O compilador analisa quais variáveis a string recebe em seus parâmetros e, consequentemente, cria a respectiva string. Isso é conhecido em C ++ como sobrecarga de função.
Isso quer dizer que com o mesmo nome de uma função, vários tipos de função podem ser feitos. O seguinte exemplo de programa pode ser encontrado no menu: Arquivo-> exemplos-> Strings-> StringsConstructors. O fluxograma pode ser observado na Figura 2.
void setup() { // Abra a comunicação serial e espere a porta abrir: Serial.begin(9600); while(!Serial) { ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa } // envie uma introdução: Serial.println("\ n \ nString Constructors:"); Serial.println(); } void loop() { // usando uma string constante: String stringOne = "Hello String"; Serial.println(stringOne); // imprime "Hello String" // convertendo para char constante em uma String: stringOne = String('a'); Serial.println(stringOne); // imprime "a" // convertendo para string constante em um objeto String: String stringTwo = String("This is a string"); Serial.println(stringTwo); // imprime "This is a string" // concatenando duas strings: stringOne = String(stringTwo + "com mais"); // imprime "Esta é uma string com mais": Serial.println(stringOne); // usando um inteiro constante: stringOne = String(13); Serial.println(stringOne); // imprime "13" // usando um int e uma base: stringOne = String(analogRead(A0), DEC); // imprime "453" ou qualquer que seja o valor de analogRead(A0) Serial.println(stringOne); // usando um int e uma base(hexadecimal): stringOne = String(45, HEX); // imprime "2d", que é a versão hexadecimal do decimal 45: Serial.println(stringOne); // usando um int e uma base(binário) stringOne = String(255, BIN); // imprime "11111111", que é o valor binário de 255 Serial.println(stringOne); // usando um longo e uma base: stringOne = String(millis(), DEC); // imprime "123456" ou qualquer que seja o valor de millis(): Serial.println(stringOne); // usando um float e as casas decimais certas: stringOne = String(5,698, 3); Serial.println(stringOne); // usando um float e menos casas decimais para usar o arredondamento: stringOne = String(5,698, 2); Serial.println(stringOne); // não faz nada enquanto verdadeiro: while(true); }
LOCALIZANDO UMA STRING DENTRO DE OUTRA STRING.
Para localizar uma string dentro de outra String podemos usar a função: String.indexOf(val) onde o parâmetro 'val' é o caractere ou seqüência de pesquisa. A função retorna o índice de 'val' dentro da string ou -1 caso a string não é encontrada. Também pode usar a função: String.indexOf(val, da) em que o parâmetro 'de' recebe do índice para iniciar a pesquisa.
As funções acima iniciam a pesquisa desde o início da string. Se quisermos iniciar uma pesquisa a partir do fim(fim) da String, podemos usar a função: string.lastIndexOf(val) ou também a função: string.lastIndexOf(val, apartir). O programa a seguir dá um exemplo de como usar essas funções e pode ser encontrado no menu: Arquivo-> exemplos-> Strings-> StringsIndexOf.
void setup() { // Abra a comunicação serial e espere a porta abrir: Serial.begin(9600); while(!Serial) { ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa } // envie uma introdução: Serial.println( "\ n \ nSTRING indexOf() e lastIndexOf() funções"); Serial.println(); } void loop() { // indexOf() returns the position(i.e. index) of a particular character in a // String. For example, if you were parsing HTML tags, you could use it: String stringOne = ""; int firstClosingBracket = stringOne.indexOf('>'); Serial.println("The index of > in the string " + stringOne + " is " + firstClosingBracket); stringOne = ""; int secondOpeningBracket = firstClosingBracket + 1; int secondClosingBracket = stringOne.indexOf('>', secondOpeningBracket); Serial.println("The index of the second > in the string " + stringOne + " is " + secondClosingBracket); // you can also use indexOf() to search for Strings: stringOne = ""; int bodyTag = stringOne.indexOf(""); Serial.println("The index of the body tag in the string " + stringOne + " is " + bodyTag); stringOne = " item item item "; int firstListItem = stringOne.indexOf(" "); int secondListItem = stringOne.indexOf(" ", firstListItem + 1); Serial.println("The index of the second list tag in the string " + stringOne + " is " + secondListItem); // lastIndexOf() gives you the last occurrence of a character or string: int lastOpeningBracket = stringOne.lastIndexOf('<'); Serial.println("The index of the last < in the string " + stringOne + " is " + lastOpeningBracket); int lastListItem = stringOne.lastIndexOf(" "); Serial.println("The index of the last list tag in the string " + stringOne + " is " + lastListItem); // lastIndexOf() can also search for a string: stringOne = " Lorem ipsum dolor sit amet Ipsem Quod "; int lastParagraph = stringOne.lastIndexOf("<p"); int secondLastGraf = stringOne.lastIndexOf("<p", lastParagraph - 1); Serial.println("The index of the second to last paragraph tag " + stringOne + " is " + secondLastGraf); // do nothing while true: while(true); }
VERIFICANDO QUANTOS CARACTERES TEM UMA STRING(COMPRIMENTO)
Para saber quantos caracteres uma string possui, podemos usar a função: string.length() que retorna a largura dos caracteres. Esta função não conta o último caractere da string, conhecido como caractere nulo. Esse caractere é hexadecimal 0x00. O programa a seguir usa a função length() e pode ser encontrado no menu: File-> Examples-> Strings-> StringLength. O fluxograma pode ser observado na Figura 12.
String txtMsg = ""; // uma string para o texto recebido unsigned int lastStringLength = txtMsg.length(); // comprimento anterior da string void setup() { // Abra a comunicação serial e espere a porta abrir: Serial.begin(9600); while(!Serial) { ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa } // envie uma introdução: Serial.println("\ n \ nString length():"); Serial.println(); } void loop() { // adiciona quaisquer caracteres recebidos à String: while(Serial.available()> 0) { char inChar = Serial.read(); txtMsg + = inChar; } // imprime a mensagem e um aviso se for alterado: if(txtMsg.length()! = lastStringLength) { Serial.println(txtMsg); Serial.println(txtMsg.length()); // se a string tiver mais de 140 caracteres, reclamar: if(txtMsg.length() <140) { Serial.println("Essa é uma mensagem de texto perfeitamente aceitável"); } else { Serial.println("Isso é muito longo para uma mensagem de texto."); } // observe a duração da próxima vez no loop: lastStringLength = txtMsg.length(); } }
REMOÇÃO DOS ESPAÇOS EM BRANCO DE UMA STRING(TRIM).
É comum na programação com microcontroladores encontrar espaços em branco no início e no final da string. Para remover esses espaços, você pode usar a função: string.trim().
Esta função modifica a string e elimina qualquer espaço em branco. O programa a seguir faz uso desta função e pode ser encontrado no menu: File-> Examples-> Strings-> StringLengthTrim. O fluxograma pode ser observado na Figura 4.
void setup() { // Abra a comunicação serial e espere a porta abrir: Serial.begin(9600); while(!Serial) { ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa } // envie uma introdução: Serial.println("\ n \ nString length() e trim():"); Serial.println(); } void loop() { // aqui está uma String com espaços vazios no final(chamado espaço em branco): String stringOne = "Olá!"; Serial.print(stringOne); Serial.print(" Serial.println(stringOne.length()); // apara o espaço em branco da string: stringOne.trim(); Serial.print(stringOne); Serial.print(" Serial.println(stringOne.length()); // não faz nada enquanto verdadeiro: while(true); }
Na última parte desta série (Parte 3 no MIC178), apresentaremos mais alguns exemplos e práticas para trabalhar com strings de texto com o Arduino Uno.
