Práticas e código de exemplo para String de texto ou string com arduino uno - Parte 2 (MIC177)
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.
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.
Figura 1. Fluxograma do Operador de Comparação
Serial.println("\n \nComparando Strings:");
// duas strings iguais:
if(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):
if(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);
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);
Serial.println(stringOne + " não é igual(ignorando o caso) " + stringTwo);
// uma string numérica comparada ao número que ela representa:
if(stringOne.toInt() == numberOne) {
// duas stringss numéricas comparadas:
if(stringOne >= stringTwo) {
Serial.println(stringOne + " > = " + stringTwo);
// operadores de comparação podem ser usados para comparar Strings para classificação alfabética também:
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:
if(stringOne.compareTo(stringDois) <0) {
Serial.println(stringOne + " vem antes " + stringTwo);
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:
stringOne = "Sensor:";
stringTwo = "Sensor:";
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.
Figura 2. Diagrama de Fluxo para Construtores de String
Serial.println("\ n \ nString Constructors:");
// usando uma string constante:
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:
Serial.println(stringTwo); // imprime "This is a string"
// concatenando duas strings:
stringOne = String(stringTwo + "com mais");
// imprime "Esta é uma string com mais":
// 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)
// usando um int e uma base(hexadecimal):
stringOne = String(45, HEX);
// imprime "2d", que é a versão hexadecimal do decimal 45:
// usando um int e uma base(binário)
stringOne = String(255, BIN);
// imprime "11111111", que é o valor binário de 255
// usando um longo e uma base:
stringOne = String(millis(), DEC);
// imprime "123456" ou qualquer que seja o valor de millis():
// usando um float e as casas decimais certas:
stringOne = String(5,698, 3);
// usando um float e menos casas decimais para usar o arredondamento:
stringOne = String(5,698, 2);
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.
Serial.println( "\ n \ nSTRING indexOf() e lastIndexOf() funções");
// 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:
int bodyTag = stringOne.indexOf("");
stringOne = "
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);
int lastListItem = stringOne.lastIndexOf("
Serial.println("The index of the last list tag in the string " + stringOne + " is " + lastListItem);
Serial.println("The index of the second to last paragraph tag " + stringOne + " is " + secondLastGraf);
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.
Figura 3. Fluxograma para saber quantos caracteres uma string possui
String txtMsg = ""; // uma string para o texto recebido
unsigned int lastStringLength = txtMsg.length(); // comprimento anterior da string
Serial.println("\ n \ nString length():");
// adiciona quaisquer caracteres recebidos à String:
txtMsg + = inChar;
// imprime a mensagem e um aviso se for alterado:
if(txtMsg.length()! = lastStringLength) {
// se a string tiver mais de 140 caracteres, reclamar:
if(txtMsg.length() <140) {
Serial.println("Essa é uma mensagem de texto perfeitamente aceitável");
Serial.println("Isso é muito longo para uma mensagem de texto.");
// observe a duração da próxima vez no loop:
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.
Figura 4. Fluxograma para eliminar o espaço em branco
Serial.println("\ n \ nString length() e trim():");
// aqui está uma String com espaços vazios no final(chamado espaço em branco):
String stringOne = "Olá!";
// apara o espaço em branco da string:
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.