Arduino Tutorial - SD Card - LCD I2C

About: Este é um canal para homemakers e DIY onde vai encontrar tutoriais úteis acerca de Electrónica, Arduíno, Robótica e Impressão 3D. Estes têm explicações simples e práticas que podem ser utilizadas para concre...

Olá meus amigos, bem vindos a mais um tutorial onde vamos mostrar-vos uma montagem que utiliza um Modulo SD Card que permite ler e gravar dados num cartão de memória e que utiliza um LCD com uma placa de comunicaçãoI2C, tendo a vantagem de serem necessários muito menos pinos no Arduino e assim mais fácil a sua utilização.

O objectivo desta montagem será gravar dados de temperatura num cartão de memória, obtidos através de um sensor temperatura, no entanto, em simultâneo será possível também visualizar esses valores temperatura através do LCD.

Estes dados serão gravados em ficheiros do tipo TXT, sendo permitido criar novos ficheiros ou apaga-los, tudo através da montagem que contem 2botões com essas funcionalidades, depois existem duas formas de visualizar os dados gravados no cartão de memória, um será através da funçãoMonitor Serial e a outra retirando o cartão de memoria da montagem e ligando-o a num PC.

O nosso sensor de temperatura normalmente é constituído por uma resistênciaNTC (Negative Temperature Coefficient), que diminui a sua resistência eléctrica com o aumento de temperatura (Ver gráfico acima), este tipo sensor é também ligado aos pinos de entrada analógica do Arduino, através da montagem de um divisor de tensão, variando assim a tensão, entre 0 e 5V nesse pino de entrada (Ver imagens acima).

Depois para que os valores de temperatura sejam reproduzidos necessitamos de um LCD 1602, ou seja, com 16colunas e 2linhas, como explicados em tutoriais anteriores podemos ligar o LCDdirectamente no Arduino, no entanto, é necessário ocupar grande parte dos pinos digitais do Arduino o que se pode tornar um problema no caso de montagens mais complexas.

Assim existe a possibilidade de utilizar equipamentos de que permitem realizar as mesmas tarefas, mas utilizando muito menos pinos e ligações, estes equipamentos utilizam protocolos de comunicação sendo apenas necessários 2, 3 ou 4 pinos e ligações para transmitir e receber informação muitas vezes até mais complexa que os sistemas mais simples.

Como não poderia deixar de ser os Arduino também têm à disposição sistemas com esse tipos de protocolos de comunicação, no caso do Arduino NANO, este tem à disposição o protocoloSERIAL ou UART, o SPI e o I2C. Estes protocolos podem ser utilizados em simultâneo na mesma montagem, no entanto, têm algumas singularidades e e características especificas, nomeadamente na quantidade e tipo de pinos (Ver esquema acima).

Protocolos de comunicação:

O protocolo de comunicação mais simples existente no Arduino é o sistema de comunicação SERIAL ou UART, este protocolo utiliza apenas os pinos digitais0 e 1, estando normalmente identificados na placa do Arduino através das inscrições RX e TX (Ver imagem acima).

Este sistema de comunicação, no entanto, apenas permite ligar2equipamentos entre eles, sendo a grande maioria das vezes utilizada com a funçãoMonitor Serial, permitindo escrever e visualizar através da janela desta função no programa do Arduino.

Apesar de esta função ser muito útil para quem está a programar no Arduino, esta origina uma pequena desvantagem, pois diminui os pinos digitais disponíveis no Arduino para o resto da montagem, ficando os pinos 0 (RX) e 1 (TX)exclusivamente para este sistema de comunicação.

Já o protocolo SPI pelo contrário permite ligar um numero ilimitado de equipamentos, sendo apenas restrito pelo numero de pinos digitais que esse equipamento tem disponível, assim, este poderá ter tantos equipamentos ligado a ele, quantos os pinos digitais deste, tendo sempre em conta que 3 desses pinos, que são os pinos11, 12 e 13, são utilizados para o sistema de comunicação não podendo ser contabilizados (Ver imagem acima).

Nesta montagem o equipamento que utiliza este sistema de comunicação é o nosso Modulo SD Card tendo este 4pinos para o funcionamento deste tipo de sistema de comunicação, sendo os pinos de dados os pinos MOSI e MISO, que no Arduino são os pinos digitais11 e 12 respectivamente.

Depois o pino13 será o de CLOCK, que no Modulo SD Card é o pino SCK, sendo este responsável por sincronizar a informação recebida e transmitida entre os equipamentos. Por Ultimo temos o pinoCS que, como já foi dito, poderá ser qualquer um dos pinos digitais sobrantes, a sua função será seleccionar qual o equipamento receberá e transmitirá a informação (Ver esquema acima).

Por ultimo o protocoloI2C já aqui foi falado num dos nossos tutoriais, no entanto, não utilizando uma placa de comunicação I2C para o LCD, este tipo de comunicação da mesma forma que os anteriores tem vantagens e desvantagens, sendo a sua principal vantagem o facto de apenas utilizar 2pinos de para que o sistema fique a funcionar correctamente.

Os pinos utilizados neste sistema são desta vez os pinos analógicosA4 e A5, sendo o A4 o pino de dados designado por SDA e o A5 o pino de CLOCK, sincronizando a recepção e transmissão da informação, mas também existem desvantagens relativamente ao numero de equipamentos que é permitido ligar, sendo neste caso 127equipamentos (Ver imagem acima).

Bem, apesar de este sistema "apenas" poder ligar 127equipamentos, esta pode não ser considerada como uma desvantagem, pois em grande parte dos nossos projectos 127equipamentos são bem mais que os necessários (Ver esquema acima).

Agora como se torna possível transmitir e receber informação através de uma única linha, isto deve-se à capacidade de este sistema de comunicação endereçar a informação, assim podemos enviar e receberinformação de e para um equipamento especifico, poupando assim neste caso os pinos dos nossos Arduinos.

Para endereçar essa informação temos de saber qual equipamento corresponde a um determinado endereço, que é definido através de um código hexadecimal, no caso da Modulo I2C para o LCD, existe a possibilidade de escolher o endereço, dentro de um determinado numero de endereços, esta selecção é possível através de um conjunto de Jumpers que esta possui.

Se combinar-mos esses Jumpers poderemos então ter endereços diferentes, assim se tivermos vários equipamentos a utilizar este sistema de comunicação saberemos com qual estamos a comunicar, não correndo o risco de comunicar com o equipamento errado, no entanto, esta placa tem mais uma singularidade, que determina quais os endereços possíveis de seleccionar, estando estes relacionados com o Chipinstalado na placa (Ver imagem acima).

Assim se encontrar instalado um Chip com a referencia de fabricantePCF8574 (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 acima).

Step 1: Montagem

Para concretizar a montagem utilizamos uma Breadboard onde vamos colocar os componentes e onde são distribuídas as suas alimentações oriundas do Arduino NANO que irão alimentar todos os componentes da montagem (Ver montagem 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 LCD 1602 e o Modulo I2C:

Estes tipos de módulos são desenvolvidos para facilitar a sua montagem, assim para instalar o Module I2C no LCD 1602 basta ligar o LCD ao Modulo I2C através das suas linhas de 16pinos, em tutoriais anteriores o LCD foi ligado directamente ao Arduino e consequentemente explicadas as funções de cada pino do LCD (Ver imagem acima).

Vejam também o Arduino Tutorial - LCD - Temperature Sensor: https://www.instructables.com/id/Arduino-Tutorial-...

Como explicado acima, os pinos do sistema de comunicaçãoI2C do Arduino NANO são os pinos analógicosA4 (SDA) e A5 (SCL), já no Modulo I2C estes estão bem identificados sendo assim fácil realizar as ligações. Depois apenas falta realizar as ligações das alimentações, positivas e negativas (Ver montagem acima).

Em relação aos Jumpers deixamos todos em aberto, assim segundo a tabela de endereços a acima mencionada, o endereço do nosso LCD será 0x3F, isto porque como nesta montagem não existe mais nenhum equipamento a utilizar estes sistema e assim não existe a necessidade de alteração.

Instalação do Modulo SD Card:

Este modulo é ainda mais fácil de utilizar, apesar de utilizar mais pinos que o sistema de comunicação diferente do anterior, neste caso o protocoloSPI, logo como referido anteriormente os pinos do Arduino para este sistema de comunicação são os pinos digitaisMISO (12), o MOSI (11), o SCK (13) e por fim o pino CS, podendo ser qualquer um dos pinos digitais restantes, nesta montagem vamos utilizar o pino10 (Ver montagem acima).

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

Com os principais componentes instalados, só nos falta colocar na montagem os botões (Push Button) e as suas respectivas resistência de 1KΩ, estes são ligados a dois dos pinos digitais dos Arduino, neste caso foram escolhidos os pinos 2 e 3.

A função de um destes botões será criar um novo ficheiro do tipo TXT, onde recomeçarão a ser gravados os valores de temperatura, permitindo assim recomeçar a gravação sem perder os dados anteriores. O outro botão terá a função de apagar sempre que necessário o ultimo ficheiro de gravação e recomeçando a gravação no ficheiro anterior, a partir da ultimo valor.

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

Será então o ponto intermédio destes dois componentes, que será ligado a um dos pinos analógicos do Arduino, sendo o escolhido o pinoA0, assim nesse pino está então um valor de tensão que pode variar entre os 0 e 5V dependendo da temperatura sentido pelo sensor (Ver imagem 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 vamos carregar o código no Arduino NANO. Agora abrimos o programa do Arduino não esquecendo que temos sempre de configurar o programa para o tipo de placa do Arduino que estamos a utilizar, neste caso é o Arduino NANO.

Caso tenham duvidas vejam o tutorial anterior, onde é explicado todo esse processo: https://www.instructables.com/id/Arduino-Tutorial-...

Vamos começar então por importar as bibliotecas necessárias à nossa montagem, a primeira biblioteca será a thermistor.h, esta permite com apenas uma função 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 qual o pino do Arduino que será ligado ao circuito do sensor de temperatura (A0), sua resistência nominal do sensor a 25ºC (10KΩ), o seu coeficiente beta e o valor da resistência colocada no circuito divisor de tensão (10KΩ).

#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 sensor.

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 pela comunicação I2C que irá interagir com o LCD.

#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ção é bem mais simples que a utilizada em tutoriais anteriores, pois já não é necessário configurar a função com todos os pinos de ligação do LCD, apenas teremos de colocar o endereço (0x3F) relativo à tabela de combinação de Jumpers da placa de comunicação I2C (Ver tabela acima) e colocar o numero de colunas (16) e linhas (2) do LCD.

Alem desta função existem outras duas que se encontram dentro da função Setup() mas com outra finalidade, sendo o caso da função lcd.backlight() que permite ligar e desligar a iluminação de fundo do LCD alterando a função para lcd.noBacklight(), como também a função lcd.init() que inicia a comunicação I2C 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();
}

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 no nosso 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 é essencial ao funcionamento da biblioteca SD.h, pois é esta que irá determinar a criação e abertura dos ficheiros no cartão de memória.

#include   //Importar a "SPI" library.<br>#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();
} 

Se observarem no código anterior, sempre que um ficheiro é aberto, tanto para escrever ou para ler, este terá de ser obrigatoriamente fechado através da função close(), isto deve-se ao facto de que só é possível abrir um ficheiro de cada vez, caso contrário poderá criar um erro durante o processo.

Não ficando esquecido, como acontece com outros tipos de comunicação no Arduino, comunicação Serial e I2C, também é necessário iniciar a comunicação SPI colocando a função SD.begin() no nosso código, para isso colocamos esta na função Setup(), alem disto é nesta função que definimos qual será o pino do Arduino que terá a função de CS na comunicação SPI.

Alem de iniciar a comunicação esta 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!!");
	}
}

Este é o código completo para a nossa montagem, onde são utilizados os conceitos descritos anteriormente, Caso queiram saber mais sobre o LCD, o sensor de temperatura ou a função Monitor Serial vejam os tutoriais "Arduino Tutorial - LCD - Temperature Sensor" e "Arduino Tutorial - Analog Input - Resistive Sensors - Monitor Serial" onde explicamos pormenorizadamente as sua característica e funcionalidades.

#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 deste Link "https://www.arduino.cc/en/Reference/HomePage".

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

Share

    Recommendations

    • Organization Contest

      Organization Contest
    • Faux-Real Contest

      Faux-Real Contest
    • Sweet Treats Challenge

      Sweet Treats Challenge

    Discussions