Bem vindos a mais um tutorial sobre o Arduino, hoje vamos mostrar-vos uma montagem que utiliza um modulo SD Card que permite ler e gravar dados num cartão de memória, esta também utiliza um LCD que estará ligado ao Arduino através de uma placa de comunicação I2C, sendo assim necessários muito menos pinos do Arduino para comunicar com o LCD.

A finalidade desta montagem será gravar dados de temperatura num cartão de memória, estes dados serão obtidos através de um sensor temperatura sendo possível também visualizar esses valores temperatura em simultaneamente no LCD.

Os dados serão gravados no cartão de memória em ficheiros do tipo TXT, sendo permitido criar novos ficheiros e apagar outros existentes, tudo isto através da montagem que terá 2 botões com essas funcionalidades atribuídas. Para visualizar os dados gravados no cartão de memória utilizaremos a janela Monitor Serial ou então retirando o cartão de memoria da montagem e ligando-o de seguida a num PC abrindo depois os ficheiros.

Para reproduzir simultaneamente os valores de temperatura utilizamos um LCD1602, significando assim que este tem 16 colunas e 2 linhas, como explicado em tutoriais anteriores podemos este tipo de LCD pode ser ligado directamente no Arduino, no entanto, são necessários muitos pinos de sinal digital o que se pode tornar um problema se estivermos perante montagens mais complexas.

Arduino Tutorial - LCD - Temperature Sensor

https://www.instructables.com/id/Arduino-Tutorial-LCD-Temperature-Sensor/

Assim existe a possibilidade de utilizar um pequeno equipamento que quando associado ao LCD permite realizar a mesma tarefa mas utilizando muito menos pinos e ligações, este equipamento utiliza o protocolo I2C, este é um dos vários tipos protocolos de comunicação possíveis de realizar com o Arduino, sendo apenas necessários 2, 3 ou 4 pinos permitindo até transmitir e receber informação muitas vezes até mais complexa que os outros sistemas.

Protocolos de comunicação:

O Arduino NANO tem à sua disposição todos estes protocolos, que são o protocolo UART, o SPI e o I2C, todos estes podem ser utilizados em simultâneo na mesma montagem, no entanto, têm algumas singularidades e características diferentes nomeadamente na quantidade e tipo de pinos utilizados (Ver esquema acima).

Protocolo UART:

O protocolo de comunicação mais simples que o Arduino NANO utiliza é o protocolo UART, este protocolo utiliza apenas 2 pinos que são os pinos de sinal digital D0 e D1, estando normalmente identificados na placa do Arduino através das inscrições RX0 e TX1 (Ver imagem acima).

Este protocolo no entanto apenas permite ligar apenas 2 equipamentos entre si, sendo a grande maioria das vezes utilizada a função Communication Serial para permitir escrever e visualizar através da janela Monitor Serial do Arduino.

Esta função é muito útil para quem está a programar no Arduino no entanto diminui os pinos de sinal digitais disponíveis no Arduino ficando os pinos RX0 e TX1 dedicados a este protocolo.

Protocolo SPI:

Já o protocolo SPI pelo contrário permite ligar um numero ilimitado de equipamentos, sendo apenas restringido pelo numero de pinos de sinal digital que o Arduino tem disponível, logo este poderá ter ligado tantos equipamentos, quantos os seus pinos de sinal digital, tendo sempre em conta que 3 desses pinos são utilizados pelo próprio protocolo, não podendo ser contabilizados, sendo estes pinos o D11, D12 e D13. (Ver imagem acima).

Esses 3 pinos dedicados ao protocolo de comunicação são designados por MOSI, MISO e SCK, tendo cada um deles uma função especifica. Os pinos MOSI e MISO serão os responsáveis pela recepção e envio dos dados de informação entre os equipamentos, sendo que o pino MOSI é o responsável por receber a informação de todos os outros equipamentos e o pino MISO será encarregue de enviar a informação para esses mesmos equipamentos.

Já o pino SCK tem uma função bastante diferente dos anteriores, pois este será responsável pela sincronização da informação recebida e enviada entre os equipamentos, isto deve-se a sua função de "Clock" que permite aos equipamentos saber quando devem realizar a leitura dos dados recebidos e quando enviar novos dados.

Por ultimo temos o pino CS, que como já foi dito anteriormente poderá ser qualquer um dos outros pinos digitais disponíveis no Arduino, a sua principal função será seleccionar o equipamento que queremos comunicar, ou seja, qual é o equipamento entre vários que irá receber a informação enviada por outros (Ver esquema acima).

Protocolo I2C:

Por ultimo mas não menos temos o protocolo I2C, este já aqui foi referenciado num dos nossos tutoriais anteriores, porem, não foi utilizado o modulo I2C especifico para o LCD, este tipo de comunicação também tem algumas vantagens, sendo a sua principal vantagem o facto de apenas utilizar 2 pinos para estes protocolo funcione correctamente.

Os pinos utilizados neste protocolo tem a designação de SDA e SCL, estes têm funções diferentes sendo apenas o pino SDA o responsável pelo envio e recepção dos dados de informação, pois este protocolo utiliza o mesmo pino para enviar e receber a informação.

Agora para que os equipamentos saibam quando devem enviar ou receber informação é necessário sincronizar estas tarefas, para isso utilizamos o pino SCL sendo este o responsável por essa sincronização. Assim para utilizar este protocolo através do Arduino podemos utilizar os pinos analógicos A4 e A5, sendo o A4 o pino de dados designado por SDA e o pino A5 de SCL ou de "Clock" de sincronização informação, a desvantagem em relação ao protocolo de SPI é o numero de equipamentos que são possíveis de serem ligados, sendo "apenas" até 127 equipamentos (Ver imagem acima).

Ora bem, apesar de este sistema "apenas" poder ligar 127 equipamentos, podemos não considerada como uma desvantagem, pois grande parte dos nossos projectos não necessita de tantos equipamentos ligados.

Agora para tornar possível a transmissão de informação entre equipamento através de apenas um único pino, este protocolo terá a necessidade de endereçar essa informação, podendo enviar e receber informação de e para um equipamento especifico, sem que sejam precisos mais pinos de comunicação.

Para endereçar essa informação temos de saber qual o endereço correspondente a um determinado equipamento, este é definido através de um código hexadecimal, que no caso da moduloI2C para o nosso LCD, existe a possibilidade de escolher o endereço dentro de uma gama de possíveis endereços, esta selecção é possível através de um conjunto de "Jumpers" que o modulo possui.

No entanto, existem outros equipamentos onde não é possível alterar ou seleccionar o seu endereço, que é o caso da placa de RTC utilizada em tutoriais anteriores, sendo para isso necessário utilizar a função I2C Scanner. Esta função permite saber qual o endereço de todos os equipamentos da montagens, podendo assim depois desencontrar esses endereços, seleccionando-os nos equipamentos que permitem escolher os endereços.

Assim sempre que sejam utilizados vários equipamentos que utilizam o mesmo protocolo de comunicação, para não correr o risco de comunicar com o equipamento errado combinamos os "Jumpers" o modulo I2C do LCD seleccionando assim endereços diferentes, no entanto, esta placa tem mais uma singularidade, pois já estão determinados quais os seus possíveis endereços a seleccionar, estando estes directamente relacionados com o "Chip" instalado no modulo (Ver imagem acima).

Assim se encontrar instalado um "Chip" com a referencia de fabricante PCF8574 (T) devemos observar a tabela da esquerda da nossa imagem, caso essa referencia de fabricante for PCF8574 (AT) a tabela a observar deve ser a direita (Ver tabelas abaixo).

Step 1: Montagem

Para concretizar a montagem utilizamos como de costume uma "Breadboard" onde vamos colocar os todos os seus componentes e onde colocamos as ligações necessárias e distribuídas as alimentações provenientes do Arduino NANO (Ver imagem acima).

Material necessário:

1x Arduino NANO;
1x Cabo Mini USB;
1x Breadboard;
1x LCD1602;
1x Modulo I2C LCD;
1x Modulo SD Card;
1x Cartão MicroSD;
1x Sensor de temperatura NTC 10KΩ;
1x Resistência 10KΩ;
2x Botão (Push Button);
2x Resistências de 1KΩ.

Instalação do LCD1602 e o Modulo I2C:

Estes tipos de módulos são desenvolvidos para facilitar as montagens, assim para instalar o moduloI2C no LCD1602 basta liga-los através dos seus 16 pinos, em tutoriais anteriores o LCD foi ligado directamente ao Arduino e consequentemente explicadas as funções de cada pino do LCD.

Arduino Tutorial - LCD - Temperature Sensor:

https://www.instructables.com/id/Arduino-Tutorial-LCD-Temperature-Sensor/

Estando assim instalado o modulo I2C no LCD apenas serão necessários 2 pinos de comunicação entre este e o Arduino NANO assim ligamos os pinos SDA e SCL do modulo aos pinos analógicos A4 e A5 respectivamente. Depois falta apenas realizar as ligações das alimentações, positivas e negativas (Ver imagem acima).

Em relação à selecção do endereço para o modulo I2C vamos deixar todos os "Jumpers" em aberto e assim segundo a tabela de endereços a acima mencionada, o endereço para o nosso LCD será 0x3F, pois como nesta montagem não existe mais nenhum equipamento a utilizar este protocolo de comunicação não existe a necessidade de alteração do endereço (Ver tabela acima).

Instalação do Modulo SD Card:

Para montar o modulo SD Card basta ligar os seus pinos digitais MOSI, MISO e SCK aos pinos D11, D12 e D13 do Arduino, por fim o pino CS pode ser ligado a qualquer um dos pinos digitais restantes, para esta montagem escolhemos o pino D10 (Ver imagem acima).

Instalação dos botões e sensor e Temperatura

Com os principais componentes da montagem instalados, só nos falta colocar na montagem os botões "Push Button" e as suas respectivas resistências de 1KΩ, estes são ligados depois também aos pinos digitais dos Arduino, sendo neste caso escolhidos os pinos D2 e D3.

Cada um destes botões terá uma finalidade dentista, tendo um destes botões a função de criar um novo ficheiro do tipo TXT, recomeçando a gravação os valores de temperatura, permitindo assim começar uma nova gravação sem perder os dados anteriores. Já o outro botão terá a função de apagar o ultimo ficheiro de gravação e recomeçar a gravação de dados no ficheiro imediatamente anterior e a partir da ultimo valor gravado.

Esses valores de temperatura têm origem no nosso sensor de temperatura, sendo este do tipo NTC com uma resistência de cerca de 10KΩ a 25ºC, este está inserido numa montagem de um divisor de tensão que também utiliza uma resistência de 10KΩ.

Este tipo de montagem com o sensor de temperatura é depois ligado ao pino de sinal analógico A0 do Arduino, variando assim a sua tensão entre 0 e 5V no seu ponto intermédio, sendo depois convertido em valores numéricos entre 0 e 1023 através do Arduino (Ver imagens acima).

Step 2: Código

Depois de terminada a montagem, ligamos o cabo Mini USB, instalamos o Cartão de memória Micro SD e carregamos o código no Arduino. Mas antes não nos podemos esquecer que temos sempre de configurar o programa para o tipo de placa de Arduino que estamos a utilizar, que neste caso é o Arduino NANO, caso tenham duvidas sobre este procedimento vejam o tutorial anterior, onde é explicado todo esse processo.

Arduino Tutorial - Fire Alarm

https://www.instructables.com/id/Arduino-Tutorial-Fire-Alarm/

Agora vamos explicar o funcionamento do nosso código, começamos sempre por importar as bibliotecas necessárias para a nossa montagem, a primeira biblioteca a importar é a thermistor.h, esta permite com apenas uma função configurar e calcular a temperatura medida pelo sensor de temperatura.

Para configurar essa função é necessário saber previamente quais as características do nosso sensor, como a sua resistência nominal do sensor a 25ºC, sendo neste caso de cerca de 10KΩ, o seu coeficiente beta e o valor da resistência colocada no circuito divisor de tensão que é 10KΩ, por de tudo isto teremos colocar o pino do Arduino ao qual o sensor de temperatura está ligado que é como sabemos o pino de sinal analógico A0.

#include "thermistor.h"	//Importar a "thermistor" library.

//Esta função define:
THERMISTOR SENSOR (Pino_Sensor, 10000, 3950, 10000);

	//Pino de entrada do sensor;
	//Resistência nominal a 25ºC do sensor;
	//Coeficiente beta do sensor;
	//Valor da resistência do circuito divisor de tensão.

Depois importamos também as bibliotecas relativas ao LCD, estas são a biblioteca LiquidCrystal,h que permite também controlar o LCD com apenas uma função e por ultimo a biblioteca Wire.h que é responsável pelo funcionamento do protocolo de comunicação I2C que irá tonar possível a iteração entre o LCD e o Arduino.

#include <Wire.h>	//Importar a "Wire" library.
#include <LiquidCrystal_I2C.h>	//Importar a "LiquidCrystal_I2C" library.

//Definir o Address de comunicação I2C do LCD e o numero de Colunas e Linhas do LCD.
LiquidCrystal_I2C lcd(0x3F, 16,2);

Como podem observar estas funções para o LCD são bem mais simples que a utilizada em tutoriais anteriores, pois já não é necessário configurar os pinos de ligação do LCD, mas apenas teremos de colocar o seu respectivo endereço de comunicação que neste caso é o 0x3F, sendo o observado através da tabela de combinação de "Jumpers" da placa I2C do LCD (Ver tabela acima) e por ultimo colocar o numero de colunas e linhas do LCD.

Alem desta função existem outras 2 que se encontram dentro da função Setup(), tendo cada uma finalidade especifica para o LCD, assim a função lcd.backlight() permite ligar e desligar a iluminação de fundo do LCD, Bastando para isso apenas alterar a palavra "backlight" para "noBacklight", alem desta também temos a função lcd.init() sendo esta a responsável pela a inicialização da comunicação entre LCD e o Arduino.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {

	//Activação da iluminação com LCD:
	lcd.backlight();	//Para ligar a iluminação de fundo do LCD.
	
	lcd.noBacklight();	//Para apagar a iluminação de fundo do LCD. 

	//Inicia a comunicação I2C com LCD:
	lcd.init();
}

Sempre que utilizamos mais que um equipamento que utiliza o protocolo I2C devemos tentar saber antes qual o seus endereços para que a nossa montagem funcione correctamente. Para isso teremos de utilizar a função I2C Scanner, esta irá verificar e escrever o na janela Monitor Serial os endereços utilizados pelos equipamentos podendo posteriormente escolher os endereços desejados.

#include <Wire.h> //Importar a "Wire" library. 

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){
	Wire.begin();
	Serial.begin(9600);
	Serial.println("\nI2C Scanner");
}
//Correr a função LOOP repetidamente:
void loop(){
	byte error, address;
	int nDevices;
	Serial.println("Scanning...");
	nDevices = 0;
	for(address = 1; address < 127; address++ ){
		// The i2c_scanner uses the return value of
		// the Write.endTransmisstion to see if
		// a device did acknowledge to the address.
		Wire.beginTransmission(address);
		error = Wire.endTransmission();
		if (error == 0){
			Serial.print("I2C device found at address 0x");
			if (address<16)
				Serial.print("0");
			Serial.print(address,HEX);
			Serial.println("  !");
			nDevices++;
		}
		else if (error==4){
			Serial.print("Unknow error at address 0x");
			if (address<16)
				Serial.print("0");
				Serial.println(address,HEX);
		}
	}
	if (nDevices == 0)
		Serial.println("No I2C devices found\n");
	else
		Serial.println("done\n");
	delay(5000);           // wait 5 seconds for next scan
}

Agora falta importar as bibliotecas necessárias ao funcionamento do nosso modulo SD Card, estas são a biblioteca SD.h que permite controlar, ler e gravar dados num cartão de memória e a biblioteca SPI.h que é responsável pela comunicação entre o modulo SD Card e o Arduino.

Para esta funcionar correctamente terá de ser criada obrigatoriamente uma variável do tipo File, esta é especifica e essencial ao funcionamento da biblioteca SD.h, pois é esta que irá determinar a criação e abertura dos ficheiros TXT no cartão de memória.

#include   //Importar a "SPI" library.
#include  //Importar a "SD" library.

File My_file; //Variável para funcionar com a biblioteca "SD". 

//Correr a função LOOP repetidamente:
void loop() { 

//Notas:
	//Apenas pode ser aberto 1 ficheiro de cada vez.
	//Antes de abrir um ficheiro novo, fechar o anterior.
	//O nome do ficheiro não pode ter mais de de 8 caracteres.
	
	//Abrir o ficheiro para depois escrever:
	My_file = SD.open(File_name, FILE_WRITE);
	
	//Condição para verificar se o ficheiro for aberto correctamente:
	if (My_file) {
		//Escreve no ficheiro:
		My_file.print("Texto...");
		
		//Fechar o ficheiro:
		My_file.close();
	} 

//Notas:
	//Apenas pode ser aberto 1 ficheiro de cada vez.
	//Antes de abrir um ficheiro novo, fechar o anterior.
	//O nome do ficheiro não pode ter mais de de 8 caracteres.
	
	//Abrir ficheiro apenas para leitura:
	My_file = SD.open(File_name);

	//Condição para verificar se o ficheiro for aberto correctamente:
	if (My_file) {
		//Enquanto o ficheiro estiver acessível:
		while (My_file.available()) {
			//Escreve no Monitor Serial os dados do ficheiro:
			Serial.write(My_file.read());
		}
	//Fechar o ficheiro:
	My_file.close();
}

Numa das condições obrigatórias sempre que um ficheiro TXT é aberto seja para escrever ou para ler os dados, este terá de ser obrigatoriamente fechado através da função close(), isto deve-se ao facto de só ser possível abrir um ficheiro de cada vez, caso contrário poderá criar um erro inutilizando o ficheiro durante o processo.

Como acontece com outros tipos de comunicação no Arduino é necessário iniciar a comunicação SPI assim utilizamos a função SD.begin() dentro da função Setup(), alem disto é nesta função que também definimos qual será o pino CS do Arduino.

Alem de iniciar a comunicação SPI a função pode ter também mais um atributo quando associada a uma condição, verificando assim se o cartão de memória está inserido correctamente.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
	//Notas:
	//Para alterar o pino no Arduino que liga ao pino CS do SD Card Module:
	//SD.begin(XX) <<<<< Apenas pinos de sinal digitais.

	//Verifica se o SD Card está inserido no leitor:
	if (!SD.begin(10)) {
		//Escreve no LCD:
		Serial.print("Falta SDcard!!");
	}
}

E pronto este é o código completo para a nossa montagem, onde são utilizados os conceitos descritos anteriormente.

#include "thermistor.h"	//Importar a "thermistor" library.

#include <Wire.h>	//Importar a "Wire" library.
#include <LiquidCrystal_I2C.h>	//Importar a "LiquidCrystal_I2C" library.

#include <SPI.h>	//Importar a "SPI" library.
#include <SD.h>	//Importar a "SD" library.

int Pino_Sensor = A0;   //Variável para selecção do pino de entrada analógica.
float Valor_Temperatura = 0;  //Variável para o cálculo da temperatura com números decimais.

//Definir o pino do sensor;
	//Resistência nominal a 25ºC;
	//Coeficiente beta do sensor;
	//Valor da resistência do sensor.
THERMISTOR sensor(Pino_Sensor, 10000, 3950, 10000);

//Definir o Address de comunicação I2C do LCD e o numero de Colunas e Linhas do LCD.
LiquidCrystal_I2C lcd(0x3F, 16,2);

File My_file; //Variável para funcionar com a biblioteca "SD".

int File_num = 0; //Variável para o número do ficheiro.
String File_title = "File"; //Variável para o título do nome do ficheiro.

//Nota:
	//O nome do ficheiro não deve ter mais de 8 caracteres no total.
String File_name; //Variável para o nome completo do ficheiro.

int Botao_New = 2;  // Variável para selecção do pino do botão novo ficheiro.
int Botao_Delete = 3; // Variável para selecção do pino do botão apagar ficheiro.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
	//Iniciar a  Communication Serial a 9600b/s:
	Serial.begin(9600);
	
	//Definição do tipo de pino (Saída ou Entrada):
	pinMode(Botao_New, INPUT);
	pinMode(Botao_Delete, INPUT);
	
	//Activação da iluminação com LCD:
	lcd.noBacklight(); //Para apagar colocar "lcd.noBacklight();"
	//Inicia a comunicação I2C com LCD:
	lcd.init();
	
//Notas:
	//Para alterar o pino no Arduino que liga ao pino CS do SDcard Module:
	//SD.begin(XX) <<<<< Apenas pinos de sinal digitais.

	//Verifica se o SDCard está inserido no leitor:
	if (!SD.begin(10)) {
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(0,0);
		//Escreve no LCD:
		lcd.print("Falta SDcard!!");
		//Atraso para o próximo passo.
		delay(3000);
	}
	 else {
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(0,0);
		//Escreve no LCD:
		lcd.print("Iniciar SDcard..");
		//Atraso para o próximo passo.
		delay(3000);
	}

	//Atribuição do nome do ficheiro:
	File_name = File_title + File_num + ".txt";
	
	//Verifica se o ficheiro existe:
	while (SD.exists(File_name)){
		//Atribuição do nome do ficheiro:
		File_num = File_num + 1;
		File_name = File_title + File_num + ".txt";
	}
}

//Correr a função LOOP repetidamente:
void loop() {
	//Se a leitura do pino botão novo ficheiro for igual a HIGH ou nível alto:
	if (digitalRead(Botao_New) == HIGH){
		//Verifica se o ficheiro existe:
		while (SD.exists(File_name)){
			//Atribuição do nome do ficheiro:
			File_num = File_num + 1;
			File_name = File_title + File_num + ".txt";
			
			//Escreve no Monitor Serial:
			Serial.println("Nome do ficheiro alterado.");
		}
	}

	//Se a leitura do pino botão apagar ficheiro for igual a HIGH ou nível alto:
	if (digitalRead(Botao_Delete) == HIGH){
		//Apaga o ficheiro.
		SD.remove(File_name);
		//Atribuição do nome do ficheiro:
		File_num = File_num - 1;
		File_name = File_title + File_num + ".txt";

		//Escreve no Monitor Serial:
		Serial.println("Ficheiro apagado.");
	}

	//Leitura do sensor de temperatura.
	Valor_Temperatura = sensor.read();
	//Cálculo do valor da temperatura.
	Valor_Temperatura = Valor_Temperatura/10;

	//Apaga a informação do LCD.
	lcd.clear();
	//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
	lcd.setCursor(0, 0);
	//Escreve no LCD:
	lcd.print("Temperatura:");
	//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
	lcd.setCursor(0, 1);
	//Escreve no LCD:
	lcd.print(Valor_Temperatura);

//Notas:
	//Apenas pode ser aberto 1 ficheiro de cada vez.
	//Antes de abrir um ficheiro novo, fechar o anterior.
	//O nome do ficheiro não pode ter mais de de 8 caracteres.

	//Abrir o ficheiro para depois escrever:
	My_file = SD.open(File_name, FILE_WRITE);

	//Se o ficheiro for aberto correctamente:
	if (My_file) {
		//Escreve no ficheiro:
		My_file.print("Temperatura: ");
		// Escreve no ficheiro:
		My_file.println(Valor_Temperatura);
		//Fechar o ficheiro:
		My_file.close();

		//Escreve no Monitor Serial:
		Serial.print("Dados gravados em ");
		Serial.println(File_name);
		Serial.println(":");
	}
	else {
		//Escreve no Monitor Serial:
		Serial.print("Erro ao abrir ");
		Serial.println(File_name);
	}
	//Abrir ficheiro apenas para leitura:
	My_file = SD.open(File_name);
	
	//Se o ficheiro for aberto correctamente:
	if (My_file) {
		//Enquanto o ficheiro estiver acessivel:
		while (My_file.available()) {
			//Escreve no Monitor Serial os dados do ficheiro:
			Serial.write(My_file.read());
		}
		//Fechar o ficheiro:
		My_file.close();

		//Escreve no Monitor Serial:
		Serial.println("Terminado...");
	}
	else {
		//Escreve no Monitor Serial:
		Serial.print("Erro ao abrir ");
		Serial.println(File_name);
	}

	//Tempo decorrido entre gravações.
	delay(2000);
}

Caso queiram saber mais ou tenham dúvidas sobre estas e outras referências do código, vejam a sua explicação detalhada no site oficial do Arduíno, através da ligação https://www.arduino.cc/en/Reference/HomePage.

Procurem os nossos tutoriais sobre o Arduino, onde são explicadas diversas montagens e o funcionamento dos seus componentes, já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.