O Site do Hardware Livre - OSHW

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.

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.

 

 Figura 1. Fluxograma do Operador de Comparação
Figura 1. Fluxograma do Operador de Comparação

 

 

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.

 

 Figura 2. Diagrama de Fluxo para Construtores de String
Figura 2. Diagrama de Fluxo para Construtores de 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 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.

 

 Figura 3. Fluxograma para saber quantos caracteres uma string possui
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
 
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.

 

 Figura 4. Fluxograma para eliminar o espaço em branco
Figura 4. Fluxograma para eliminar o espaço em branco

 

 

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.

BUSCAR DATASHEET


N° do componente 

(Como usar este quadro de busca)

Opinião

Mês de Muito Trabalho (OP197)

   Estamos em setembro de 2018 e continuamos com nosso trabalho, realizando palestras, viagens, escrevendo artigos, livros e muito mais. Em nossas duas últimas palestras, uma na Uninove e a outra na ETEC Albert Einstein, ambas de São Paulo, pudemos constatar de forma bastante acentuada um fato importante , que constantemente salientamos em nosso site desde seu início. 

Leia mais...

Homem
O homem é incapaz de viver sí, e é incapaz também de viver em sociedade. (Lhomme est incapable de vivre Seul et Il est incapable aussi de vivre em societé.)
Duhamel (1884 1966) O Deserto de Bivres - Ver mais frases


Instituto Newton C Braga
Entre em contato - Como Anunciar - Políticas do Site

Apoio Social
Lions Clube de Guarulhos Sul SOS Mater Amabilis
Advertise in Brazil
If your business is Electronics, components or devices, this site is the correct place to insert your advertisement (see more)