APOSTILAPARTE2a234183

Prévia do material em texto

10. ARRAYS E A CLASSE String 
 
Os arrays muitas vezes são chamados de listas, vetores ou matrizes, 
são muito semelhantes a uma variável comum, utilizam o mesmo tipo de 
declaração, as mesmas convenções de nomeação e podem armazenar os 
mesmos tipos de dados de uma variável. A grande diferença é que um array é 
composto por elementos que são identificados através de um índice. 
Uma analogia que podemos fazer com um array é com um hotel, onde 
temos todos os quartos iguais, da mesma forma que localizamos nosso quarto 
pelo número no array acessamos determinado elemento pelo índice. 
 
Definindo arrays e acessando seus elementos 
 
Um array é uma coleção de um ou mais objetos, do mesmo tipo, 
armazenados em endereços adjacentes de memória. Cada objeto é chamado 
de elemento do array. Da mesma forma que para variáveis simples, damos um 
nome ao array. O tamanho do array é o seu número de elementos. Cada 
elemento do array é numerado, usando um inteiro chamado de índice. No 
Arduino, a numeração começa com 0 e aumenta de um em um. Assim, o último 
índice é igual ao número de elementos do array menos um. 
 
Por exemplo, podemos definir um array chamado Pin de tamanho 8 para 
armazenar o número dos pinos utilizados em projeto: 
 
 int Pin[8]; 
 
Quando o compilador encontra esta definição, ele aloca 16 bytes 
consecutivos de memória (dois bytes - referente a cada int - para cada pino), 
como o Arduino tem apenas 2K de memória é importante não criar variáveis 
que não vão ser utilizadas. Cada pino pode ser acessado dando o nome do 
array e o índice entre colchetes: como Pin[0] (para o primeiro pino), Pin[1] (para 
o segundo pino), e assim por diante, até o último pino, Pin[7]. 
 
Podemos também definir um array e já atribuir valores aos seus 
elementos, para isto basta indicar os valores entre chaves “{ }“ e separados por 
virgula “,” . 
 
Int Pin[ ] = { 3, 4, 5, 6, 7, 8, 9, 10} 
 
Neste caso não é necessário definir o tamanho, pois o compilador conta 
o número de elementos e atribui ao array. Observe que este tipo de atribuição 
de valores só pode ser feita quando você está declarando a variável, o código 
representado abaixo provocaria erro na compilação. 
 
Int Pin[8] ; 
Pin[ ] = { 3, 4, 5, 6, 7, 8, 9, 10}; 
 
Para atribuir valores depois de declarada a variável é necessário 
referenciar o índice do elemento. 
 
Pin[0] = 3; 
Pin[1] = 4; 
Pin[2] = 5; 
 ⁞ 
Pin[7] = 10; 
 
Neste caso também poderíamos utilizar uma estrutura de repetição para 
atribuição de valores aos elementos. 
 
Int Pin[8] ; 
for (int i = 0 ; i < 8 ; i++) 
{ 
 Pin[i] = i+3; 
} 
 
 
 
Exemplo I 
 
Faça com que 4 LEDs acendam em sequência conforme a figura abaixo 
representada. 
 
 
 
Código fonte: Simular trocando as três cores do RGB 
 
int Pin[] = { 4, 5, 6, 7}; 
 
void setup() { 
 for (int i = 0 ; i < 4 ; i++) 
 { 
 pinMode(Pin[i],OUTPUT); 
 digitalWrite(Pin[i],LOW); 
 } 
 } 
 
void loop() { 
 digitalWrite(Pin[0],HIGH); 
 digitalWrite(Pin[3],LOW); 
 delay(500); 
 for (int i = 1 ; i < 4 ; i++) 
 { 
 digitalWrite(Pin[i],HIGH); 
 digitalWrite(Pin[i-1],LOW); 
 delay(500); 
 } 
 } 
 
 
 
STRINGS 
 
Muitas vezes é necessário armazenarmos palavras ou até mesmo 
frases, uma forma muito utilizada é através de um array de caracteres (tipo 
char). Neste caso cada elemento do array contém uma letra da palavra ao final 
do array deve ser inserido um elemento com o caractere nulo (“\0”) indicando o 
final da frase ou palavra, ou seja, para armazenarmos a palavra UNISANTA 
precisamos de um array de 9 elementos, um para cada letra da palavra e mais 
um para o caractere nulo. 
 Abaixo representamos varias formas de se declarar e iniciar um array de 
caracteres. 
 
 char palavra[9]; 
Neste caso foi criado um array com nove elementos, como nenhum valor 
foi atribuído todos elemento são preenchidos com o caractere nulo. 
 
 char palavra[9] = {'U', 'N', 'I', 'S', 'A', 'N', 'T', 'A', '\0'}; 
Aqui declaramos o array e preenchemos os elementos com os 
caracteres da palavra UNISANTA mais o nulo indicando o final da 
palavra. 
 
 char palavra[9] = {'U', 'N', 'I', 'S', 'A', 'N', 'T', 'A'}; 
Neste caso não foi atribuído o caractere nulo de final de palavra porem 
ele será atribuido automaticamente pelo Arduino. 
 
 char palavra[9] = “UNISANTA”; 
O Arduino adiciona uma letra da palavra a cada elemento e inclui o 
caractere nulo no final. 
 
 char palavra[ ] = “UNISANTA”; 
O Arduino vai assumir automaticamente o tamanho do array, adiciona 
uma letra da palavra a cada elemento e inclui o caractere nulo no final. 
 
 char palavra[20] = “UNISANTA”; 
O array pode ser utlizado para guardar palavra ou frases maiores. 
Note que quando escrevemos uma string utilizamos o texto entre aspas 
duplas (“UNISANTA”) e quando estamos nos referindo a um único caractere 
(variável do tipo char) utilizamos as aspas simples ou apóstrofes (‘U’). 
 
Exemplo II 
 
 Ler uma entrada de caracteres escritos no Serial Monitor, armazenar em 
um array de caracteres e escrever no de volta no Serial Monitor. 
 
Código fonte: 
char texto[10]; 
void setup() 
{ 
 Serial.begin(9600); 
} 
void loop() 
{ 
 if (Serial.available() > 0) { 
 delay(100); 
 int tamanho = Serial.available(); 
 for (int i = 0; i < tamanho; i++) { 
 if (i < 10) { 
 texto[i] = Serial.read(); 
 texto[i+1] = '\0'; 
 } 
 else { 
 Serial.read(); 
 } 
 } 
 Serial.println(texto); 
 } 
} 
 
Explicação do código fonte:Inicialmente temos um array do tipo char para 10 
elementos “texto[10]”(9 caracteres + o nulo). No setup foi apenas inicializado o 
Serial Monitor. No loop, primeiramente verificamos se tem algum dado no 
buffer, caso tenha é esperado 100ms para garantir que o buffer seja 
preenchido, em seguida a quantidade de caracteres digitados no Serial Monitor 
será armazenado na variável “tamanho”. Com base na quantidade de 
elementos da variável “tamanho” serão efetuadas as repetições através da 
estrutura FOR, assim, será lido um caractere por vez e armazenado na variável 
“texto[i]” até que seja preenchido o array os dados obtidos após o array estar 
completo serão apenas lidos garantindo o esvaziamento do buffer. Fora do 
FOR o comando Serial.println(texto); mostrará na tela do Serial Monitor a 
informação digitada após pressionarmos o botão Send. 
 
A CLASSE STRING 
 
 Vamos supor que você armazenou em um array de caracteres chamado 
Texto, uma string proveniente do Serial Monitor. Agora você quer comparar 
este array com a palavra “ENGENHARIA” provavelmente iria usar este tipo de 
estrutura: 
char Texto[] = “ENGENHARIA”; 
 if ( Texto == “ENGENHARIA”) 
 { 
 Seqüência de comandos 
 } 
 Neste caso independente do conteúdo armazenado no array Texto essa 
comparação nunca será verdadeira pois, a variável Texto não é uma string ela 
é uma coleção de caracteres então essa comparação deveria ser feita 
caractere a caractere, como vemos a seguir. 
 if ( Texto[0] == 'E') 
 { if ( Texto[1] == 'N') 
 { if ( Texto[2] == 'G') 
 { 
 ⁞ 
 } 
 } 
 } 
 Imagine se fossemos utilizar este tipo de comparação para varias 
palavras, isso acarretaria em um código fonte enorme que utilizaria uma grande 
quantidade de memória e provocando aumento no tempo de processamento. 
Para resolver este tipo de problema, a partir da versão0019 do Arduino, foi 
inserida a Classe String que, embora consuma mais memória que um array, 
nos permite utilizar e manipular strings de texto de uma maneira mais completa 
aos arrays de caracteres. Você pode concatenar textos, adicionar trechos de 
texto, pesquisar expressões no texto e substituir trechos, e muito mais. 
 A declaração de um objeto da classe String é semelhante a declaração 
de uma variável, basta utilizar String (o S tem que estar em maiúsculo) e nome 
do objeto. 
Exemplo: String palavra; 
 
Assim com fazemos com as variáveis também podemos atribuir um valor 
no momento em que declaramos o objeto. 
 
Exemplo: String palavra = “UNISANTA”; 
 
Com um objeto da classe String fica fácil fazer a comparação com uma 
palavra ou até mesmo uma frase, no caso do problema do início deste tópico é 
só armazenar o array em um objeto da classe string e depois fazer a 
comparação, como pode ser visto a seguir. 
char Texto[]; 
 ⁞ 
(sequência de comandos para preencher o array) 
 ⁞ 
String StrTexto = Texto; 
if (StrTexto == “ENGENHARIA”) 
 { 
 Seqüência de comandos 
 } 
 
Neste caso criamos uma String chamada StrTexto que já na sua 
declaração recebeu o valor contido no array chamado Texto, depois é só 
efetuar a comparação com a palavra desejada que no nosso exemplo foi 
“ENGENHARIA”. 
 
 
 
 
Exemplo III 
 
 Ler um string do Serial Monitor e comparar com a palavra UNISANTA, 
no caso de coincidência escrever o string no Serial Monitor seguido de “OK”, 
caso contrário escrever o string seguido de “DISCORDANTE”. 
 
Código fonte: 
 
char Texto[9]; 
String StrTexto; 
void setup() 
{ 
 Serial.begin(9600); 
} 
 
void loop() 
{ 
 if (Serial.available() > 0) 
 { 
 delay(100); 
 int tamanho = Serial.available(); 
 for (int i = 0; i < tamanho; i++) 
 { 
 if (i<8) 
 { 
 Texto[i] = Serial.read(); 
 Texto[i+1] = '\0'; 
 } 
 else { Serial.read(); } 
 } 
 StrTexto = Texto; 
 Serial.print(StrTexto); 
 if (StrTexto == "UNISANTA") 
 { 
 Serial.println(" - OK"); 
 } 
 else 
 { 
 Serial.println(" - DISCORDANTE"); 
 } 
 } 
} 
 
Explicação do código fonte: Inicialmente declaramos um array do tipo char 
para 9 elementos “Texto[9]”(8 caracteres + o nulo) e um objeto StrTexto da 
classe String. No setup foi apenas inicializado o Serial Monitor. No loop, 
primeiramente verificamos se tem algum dado no buffer, caso tenha é 
esperado 100ms para garantir que o buffer seja preenchido, em seguida a 
quantidade de caracteres digitados no Serial Monitor será armazenado na 
variável “tamanho”. Com base na quantidade de elementos da variável 
“tamanho” serão efetuadas as repetições através da estrutura FOR, assim, 
será lido um caractere por vez e armazenado na variável “texto[i]” até que seja 
preenchido o array os dados obtidos após o array estar completo serão apenas 
lidos garantindo o esvaziamento do buffer. Fora do FOR o objeto StrTexto 
recebe o conteúdo do array Texto, em seguida este conteúdo é exibido no 
Serial Monitor. Se a palavra armazenada for igual a “UNISANTA” exibirá a 
mensagem “OK” senão, exibirá a mensagem “DISCORDANTE”. 
 
Métodos da Classe String 
 
A classe String possui vários métodos que auxiliam no tratamento e 
depuração de uma string. Para aplicar um método da classe devemos colocar o 
nome do objeto criado seguido de um ponto e o nome do método que se quer 
utilizar. Se quisermos, por exemplo, utilizar o método indexOf para uma string 
chamada StrTexto devemos escrever StrTexto.indexOf . A seguir vamos 
explicar alguns métodos desta classe. 
 
 indexOf – este método retorna a posição de um caractere ou sequência de 
caracteres dentro da String. 
Sintaxe: nome_do_objeto.indexOf(caracteres, posição do inicio da procura) 
Exemplo: 
 String Texto = "ENGENHARIA"; 
 int i = Texto.indexOf('A'); 
 Serial.println(i); 
 // O valor de i será igual a 6 pois a posição inicial é a 0. 
 i = Texto.indexOf('A',7); 
 Serial.println(i); 
 // O valor de i será igual a 9. 
 i = Texto.indexOf('U'); 
 Serial.println(i); 
 // O valor de i será igual a -1 pois não existe coincidência. 
 i = Texto.indexOf("NH"); 
 Serial.println(i); 
 // O valor de i será igual a 4. 
 
 length() - este método retorna o comprimento do objeto String. 
Sintaxe: nome_do_objeto.length() 
Exemplo: 
 String Texto = "ENGENHARIA"; 
 Serial.println(Texto.length()); 
// O valor impresso será 10 que é o comprimento da palavra 
ENGENHARIA. 
 
 trim() – este método retira os espaços em branco do começo e do final da 
string. 
Sintaxe: nome_do_objeto.trim () 
Exemplo: 
 String Texto = " ENGENHARIA "; 
 Texto.trim(); 
 Serial.println(Texto); 
// O valor impresso será ENGENHARIA sem os espaços iniciais e 
finais. 
 
 toLowerCase() – este método transforma todos os caracteres do objeto 
String em letras minúsculas. 
Sintaxe: nome_do_objeto. toLowerCase () 
Exemplo: 
 String Texto = "ENGENHARIA"; 
 Texto. toLowerCase (); 
 Serial.println(Texto); 
// O valor impresso será engenharia. 
 
 
 toUpperCase() – este método transforma todos os caracteres do objeto 
String em letras maiusculas. 
Sintaxe: nome_do_objeto. toUpperCase() 
Exemplo: 
 String Texto = "engenharia"; 
 Texto. toUpperCase(); 
 Serial.println(Texto); 
// O valor impresso será ENGENHARIA. 
 
 
 replace() – com este método podemos substituir um determinado caractere 
da String por outro, ele também pode ser utilizado para substituir uma 
sequência de caracteres. 
Sintaxe: 
nome_do_objeto.replace(caractere a ser substituído, caractere substituto) 
Exemplo: 
 String Texto = "engenharia"; 
 Texto. replace("e" , "3"); 
 Texto. replace("a" , "4"); 
 Serial.println(Texto); 
// O valor impresso será 3ng3nh4ri4. 
Texto = "Eng. Unisanta"; 
 Texto. replace("Eng." , "Engenharia"); 
 Serial.println(Texto); 
// O valor impresso será Engenharia Unisanta. 
 
 charAt() – este método retorna o caractere existente em uma determinada 
posição. 
Sintaxe: nome_do_objeto.charAt(índice da posição) 
Exemplo: 
 String Texto = "Engenharia"; 
 Serial.println(Texto.charAt(2)); 
// O valor impresso será o caractere g. 
 
 setCharAt() – este método insere o caractere determinado na posição 
indicada. 
Sintaxe: nome_do_objeto.setCharAt(índice da posição, caractere) 
Exemplo: 
 String Texto = "Engenharia unisanta"; 
 Texto.setCharAt(11, 'U'); 
 Serial.println(Texto.setCharAt(2)); 
// O valor impresso será Engenharia Unisanta. 
 
 
 substring() – com este método retorna a substring compreendida entre as 
posições indicadas. 
Sintaxe: nome_do_objeto.substring(posição inicial, posição final) 
Obs.: A aposição final pode ser suprimida, neste caso será retornado a 
substring compreendida entre a posição indicada e o final da string. 
Exemplo: 
 String Texto = "ENGENHARIA"; 
 Serial.println(Texto.substring(3,6)); 
// O valor impresso será ENH. 
 Serial.println(Texto.substring(6)); 
 // O valor impresso será ARIA. 
 
 toCharArray() – copia o conteúdo de um objeto do tipo string para um array 
de caracteres. 
Sintaxe: nome_do_objeto. toCharArray (nome do array, tamanho) 
Obs: No tamanho deve ser considerada uma unidade a mais para a 
inserção do caractere nulo de final de array. 
Exemplo: 
 String Texto = "ENGENHARIA"; 
 char str[10] = "XXXXXX";Serial.println(str); 
 // O valor impresso será XXXXXX. 
 Texto.toCharArray(str,11); 
 Serial.println(str); 
 // O valor impresso será ENGENHARIA. 
 
 
 toInt() – converte o conteúdo de um objeto do tipo string para inteiro. Ao 
primeiro caractere encontrado na string que não corresponder a um 
algarismo a conversão é interrompida. 
Sintaxe: nome_do_objeto.toInt() 
Exemplo: 
 String Texto = "1235"; 
 i = Texto.toInt(); 
 Serial.println(i); 
 // será exibido 1235. 
 Texto = "12A35"; 
 i = Texto.toInt(); 
 Serial.println(i); 
 // será exibido 12. 
 
 
 
Capítulo 10 – Exercícios 
 
1) Ligar um LED RGB ao Arduino e receber um caractere através do Serial 
Monitor. Se a letra “R” for digitada deve acender a cor vermelha, quando a 
letra ”G” for digitada devera acender a cor verde e no caso de digitado a 
letra “B” deve acender a cor azul. 
 
 
 
2) Receber uma frase com no máximo 20 caracteres via Serial Monitor, 
identificar qual é o último caractere, verificar quantas vezes ele aparece na 
frase e exibir o resultado no Serial Monitor. 
 
3) Receber através do Serial Monitor a frequência (identificada pela letra F na 
frente do número) e a duração em milissegundos (identificada pela letra D 
na frente do número) de uma sequência de 3 tons, identificar e reproduzir 
em um buzzer ligado Arduino. 
Exemplo de dados: F800 D500 F545 D1000 F720 D650