Práticas e código de exemplo para string de texto ou string com Arduino Uno - Parte 1 (MIC176)

    Muitos aplicativos com microcontroladores usam strings ou strings de texto. Devido ao grande desenvolvimento da Internet e Ethernet em microcontroladores e sistemas de mensagens móveis ou GSM, as mensagens de texto são amplamente utilizadas para atender a essas necessidades. Também projetos que se comunicam com computadores ou mostram informações em telas de LCD, usam muito as strings. Muitas câmeras de vigilância, sistemas de comunicação de rádio e antenas, equipamentos industriais e médicos, etc., usam páginas da Web para fornecer informações aos usuários e podem ser configuradas por meio de um computador portátil. Neste artigo vamos aprender como controlar strings para uso em projetos eletrônicos com o Arduino.

MIC031S

   É possível adicionar ao sistema Arduino, uma placa que contém uma interface de rede Ethernet. Isto torna possível criar servidores web dentro de um microcontrolador e dar informações aos usuários. Também é comum usar páginas da Web para configurar e monitorar os equipamentos eletrônicos mais modernos.

   Assim, o que está sendo desenvolvido na chamado de Internet das Coisas (IoT). Um sistema em que equipamentos elétricos e eletrônicos podem ser controlados pela internet. Páginas da Web são strings de texto ou strings que usam uma linguagem chamada HTML ou Text Markup Language e, para transportar strings, ele usa um protocolo chamado HTTP ou Text Transport Protocol. Também os sistemas de posicionamento geográfico global ou GPS usam string para fornecer informações. Mensagem móvel ou sistemas GSM também usam strings. Tudo isso amplamente usa strings e é por isso que é importante saber como criá-las e manipulá-las.

Figura 1. Arduino Uno Board

   Na Figura 1 podemos ver a placa do Arduino Uno e na Figura 2 seu IDE ou ambiente de desenvolvimento e programação.

Figura 2. Ambiente de desenvolvimento do Arduino Uno

   Os programas usados neste artigo podem ser encontrados no menu: File-> Examples-> Strings do Arduino IDE. Veja a figura 3.

Figura 3. Menu por exemplo código com strings

   Strings de texto ou strings são um tipo de dado usado na maioria dos compiladores para microcontroladores. O Arduino IDE possui uma biblioteca dedicada ao String. Esta biblioteca tem as seguintes funções:

String()

charAt()

compareTo()

concat()

endsWith()

equals()

equalsIgnoreCase()

getBytes()

indexOf()

lastIndexOf()

length()

remove()

replace()

reserve()

setCharAt()

startsWith()

substring()

toCharArray()

toInt()

toFloat()

toLowerCase()

toUpperCase()

trim()

    Neste artigo vamos estudar a maioria deles com programas práticos.

   Cadeias de texto são como matrizes de caracteres ASCII. Isso significa que eles ocupam um lugar na memória e que um caractere segue o outro ou é depois do outro. A Figura 4 mostra exemplos de cadeias de texto armazenadas na memória.

Figura 4. Exemplos de strings de memória

   Existem duas maneiras de criar strings de texto. Uma é criar um objeto ou estrutura da classe String. O seguinte é um exemplo:

String reportString = "SensorReading: 456";

   Na linha acima de código, ele criou uma String chamada: reportString e inicializado com texto: SensorReading: 456. Notamos que objetos ou dados de cadeia em C++ deve ser escrito com 'S' (letra maiúscula). Objetos em C ++ são muito semelhantes a estruturas na linguagem C. Portanto, podemos dizer que Objetos são como variáveis ??ou dados de um determinado tipo ou classe. Para o caso deste artigo, trabalharemos com objetos da classe String.

   A outra maneira é criar uma matriz de caracteres e o seguinte é um exemplo:

char nameString [] = "Jhon";

   A linha de código anterior cria uma matriz de caracteres e armazena o nome: Jhon. Esta maneira de criar string é aquela usada na programação em C. Algumas das funções mais utilizadas neste estilo C de programação para manipular string são:

strset(str1, str2) // Coloque um valor de texto na string.

strcap(str1, str2) // Seal 2 string.

strlen(str1) // Retorna quantos caracteres a string possui.

   Uma desvantagem ao usar string ou cadeias de texto na linguagem C é que o programador deve definir previamente um array ou espaço de memória para armazenar os caracteres da string. Se a cadeia em algum ponto for maior que o projetado, pode haver algumas desvantagens. Já na linguagem C ++, isso é gerenciado pelo próprio sistema de memória e, por esse motivo, é melhor usar string em C ++.

Para o desenvolvimento deste artigo, usaremos principalmente objetos String ou o estilo de programação C ++. Os resultados dos programas de exemplo podem ser vistos no monitor serial do IDE. Veja a Figura 5. Há muitas vantagens em usar objetos String. Entre eles, uma melhor legibilidade no código escrito e funções mais poderosas para lidar com string.

Figura 5. Terminal Serial do Arduino IDE

OPERADOR DE ADIÇÃO PARA STRING.

   Para adicionar um valor a uma string ou string de texto, usamos o operador de adição, representado pelo símbolo '+'. Como mencionado acima, a linguagem de programação do Arduino é baseada no C / C ++. Por esse motivo, muitos tipos de dados são baseados em objetos ou estruturas, facilitando a programação. Tal é o caso das cadeias de texto ou string, que permitem fácil manipulação e concatenação.

No programa a seguir, criaremos 3 strings, que serão adicionadas com outros valores de tipo string e numérico. O programa pode ser encontrado no menu: File-> Examples-> Strings-> StringAdditionOperator. O fluxograma pode ser observado na Figura 6.

Figura 6. Fluxograma do Operador de Adição

// declara três strings:
String stringOne, stringTwo, stringThree;
 
void setup() {
  // inicializa serial e espera que a porta abra:
  Serial.begin(9600);
  while(! Serial) {
    ; // espera que a porta serial se conecte. Necessário apenas para porta USB nativa
  }
 
  stringOne = String("Você adicionou");
  stringTwo = String("esta string");
  stringThree = String();
  // envie uma introdução:
  Serial.println("\ n \ nAdicionando Strings juntos(concatenação):");
  Serial.println();
}
 
void loop() {
  // adicionando um inteiro constante a uma String:
  stringThree = stringOne + 123;
  Serial.println(stringThree); // imprime "Você adicionou 123"
 
  // adicionando um inteiro longo e constante a uma String:
  stringThree = stringOne + 123456789;
  Serial.println(stringThree); // imprime "Adicionou 123456789"
 
  // adicionando um caractere constante a uma String:
  stringThree = stringOne + 'A';
  Serial.println(stringThree); // imprime "Adicionou A"
 
  // adicionando uma string constante a uma String:
  stringThree = stringOne + "abc";
  Serial.println(stringThree); // imprime "Você adicionou abc"
 
  stringThree = stringOne + stringDois;
  Serial.println(stringThree); // imprime "Adicionou esta cadeia"
 
  // adicionando um inteiro variável a uma String:
  int sensorValue = analogRead(A0);
  stringOne = "Valor do sensor:";
  stringThree = stringOne + sensorValue;
  Serial.println(stringThree); // imprime "Sensor Value: 401" ou qualquer outro valor que o analogRead(A0) tenha
  // adicionando uma variável long integer a uma String:
  stringOne = "millis() valor:";
  stringThree = stringOne + millis();
  Serial.println(stringThree); // imprime "O millis: 345345" ou qualquer outro valor que millis() tenha não faz nada enquanto verdadeiro:
  while(true);
}

APÊNDICE E OPERADOR DE CONCATENAÇÃO.

   Uma das operações mais utilizadas é adicionar um texto no final de uma string. Para isso, podemos usar o operador '+ ='. Quando usamos esse operador, o compilador adiciona ao final da string. No programa a seguir podemos ver vários usos deste operador. Também é possível usar a função concat() para fazer concatenações de dados. O programa de exemplo pode ser encontrado no menu: File-> Examples-> Strings-> StringAppendOperator. O fluxograma pode ser visto na Figura 7.

Figura 7. Fluxograma para Operador de Concatenação

String stringUm, stringDois;
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("Sensor");
  stringTwo = String("valor");
  // envie uma introdução:
  Serial.println("\ n \ nAppendendo a uma String:");
  Serial.println();
}
 
void loop() {
  Serial.println(stringOne); // imprime "Sensor"
 
  // adicionando uma string a uma String:
  stringOne + = stringDois;
  Serial.println(stringOne); // imprime "Valor do sensor"
 
  // adicionando uma string constante a uma String:
  stringOne + = "para entrada";
  Serial.println(stringOne); // imprime "Valor do sensor para entrada"
 
  // adicionando um caractere constante a uma String:
  stringOne + = 'A';
  Serial.println(stringOne); // imprime "Valor do sensor para entrada A"
 
  // adicionando um inteiro constante a uma String:
  stringOne + = 0;
  Serial.println(stringOne); // imprime "Valor do sensor para entrada A0"
 
  // adicionando uma string constante a uma String:
  stringOne + = ":";
  Serial.println(stringOne); // imprime "Valor do sensor para entrada"
 
  // adicionando um inteiro variável a uma String:
  stringOne + = analogRead(A0);
  Serial.println(stringOne); // imprime "Valor do sensor para entrada A0: 456" ou qualquer que seja o analogRead(A0)
 
  Serial.println("\ n \ nalterando os valores das Strings");
  stringOne = "Um inteiro longo:";
  stringTwo = "O millis():";
// adicionando um inteiro longo e constante a uma String:
  stringOne + = 123456789;
  Serial.println(stringOne); // imprime "Um inteiro longo: 123456789"
 
  // usando concat() para adicionar uma variável longa a uma String:
  stringTwo.concat(millis());
  Serial.println(stringTwo); // imprime "O millis(): 43534" ou qualquer que seja o valor do millis() é
 
  // não faz nada enquanto verdadeiro:
  while(true);
}

TROCA DE MINUSCULAS (LOWER CASE) PARA MAIÚSCULAS (UPPER CASE).

   A biblioteca para manipular texto ou string, possui instruções ou funções para passar de minúsculas para maiúsculas. No exemplo a seguir, criamos um pequeno texto: "" e com a função toUpperCase(); nós convertemo-lo para maiúsculas, isto é: "". Em seguida, o programa cria uma seqüência de caracteres maiúsculas e passamos para letras minúsculas. O programa de exemplo pode ser encontrado no menu: File-> Examples-> Strings-> StringCaseChanges. O fluxograma pode ser observado na Figura 8.

Figura 8. Diagrama de Fluxo para Minúsculas e Maiúsculas

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 \ nAlterações de maiúsculas e minúsculas:");
  Serial.println();
}
 
void loop() {
  // toUpperCase() altera todas as letras para maiúsculas:
  String stringOne = "";
  Serial.println(stringOne);
  stringOne.toUpperCase();
  Serial.println(stringOne);
 
  // toLowerCase() altera todas as letras para minúsculas:
  String stringTwo = "";
  Serial.println(stringTwo);
  stringTwo.toLowerCase();
  Serial.println(stringTwo);
 
 
  // não faz nada enquanto verdadeiro:
  while(true);
}

OBTENDO (GET) E COLOCANDO (SET) CARACTERES EM UMA STRING

    Para saber ou obter um caractere de uma determinada posição em uma string, você pode usar a função string.charAt(n). É o parâmetro 'n' que recebe a função, é a posição do caractere na string. A função retorna o valor do caractere. Para colocar (set) o valor de um caractere em uma string, usamos a função string.setCharAt(index, c).

O parâmetro index é a posição do personagem. O parâmetro 'c' é o valor do caractere que você deseja modificar. O programa a seguir usa essas funções para obter e colocar o valor dos caracteres em uma string e pode ser encontrado no menu: File-> Examples-> Strings-> StringCharacters. O fluxograma pode ser visto na Figura 9.

Figura 9. Diagrama de Fluxo para Obter e Colocar Caracteres

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
  }
 
  Serial.println("\ n \ nString charAt() e setCharAt():");
}
 
void loop() {
  // faz uma String para relatar a leitura do sensor:
  Cadeia reportString = "SensorReading: 456";
  Serial.println(reportString);
 
  // o dígito mais significativo da leitura está na posição 15 no reportString:
  char mostSignificantDigit = reportString.charAt(15);
 
  String message = "O dígito mais significativo da leitura do sensor é:";
  Serial.println(mensagem + mostSignificantDigit);
 
  // adiciona espaço em branco:
  Serial.println();
 
  // você também pode definir o caractere de uma String. Altere o: para um caractere =
  reportString.setCharAt(13, '=');
  Serial.println(reportString);
 
  // não faz nada enquanto verdadeiro:
  while(true);
}

 Na segunda parte deste artigo, veremos como usar operadores para comparar strings, verificar quantos caracteres uma string possui e como remover os espaços em branco. Parte 2 em MIC177.