Commit a2d0f4a7 authored by Guilherme Porto's avatar Guilherme Porto
Browse files

Upload New File

parent a8b68974
#include <Wire.h>
#include "FS.h"
#include "SD.h"
#include "SPI.h"
/*
Biblioteca para Cartão SD - comunicação SPI.
*/
#include <Adafruit_ADS1X15.h>
/*
Biblioteca para conversor ADC - ADS1015
Gerenciador de bibliotecas IDE Arduíno
Versão 2.2.0
*/
#include <time.h>
#include "secrets.h"
#include "ThingSpeak.h" // always include thingspeak header file after other header files and custom macros
/* - Bibliotecas para a interface gráfica;
- necessário verifcar em secrets.h o canal e chave API estão de acordo com o site/plataforma;
- Na plataforma não trocar arbitrariamente;
*/
#include <WiFi.h>
/*Biblioteca para conexão com a rede WiFi comum.*/
#include <WiFiClientSecure.h>
#include "esp_wpa2.h"
/*Biblioteca para conexão com a rede WiFi privada/autentificação. */
/**********************************************************************************************/
#define EAP_ANONYMOUS_IDENTITY "" // Identidade anônima - Sem caracteres para Eduroam UFRGS
#define EAP_IDENTITY "xxxxxx@ufrgs.br" // Nro Cartão UFRGS + @ufrgs,br
#define EAP_PASSWORD "Senha" // Senha portal UFRGS
const char* Ssid = "eduroam"; // eduroam SSID - Identificação da rede
const char* host = "ufrgs.br"; // external server domain for HTTPS connection
int counter = 0; // Contador para reconexão com o servidor.
// Chave de autentificação da rede privada (Eduroam UFRGS)
const char* test_root_ca = \
"-----BEGIN CERTIFICATE-----\n" \
"MIIFCTCCA/GgAwIBAgIQV0cXGWPWQYpD97TkhRl8LzANBgkqhkiG9w0BAQsFADCB\n" \
"DELMAkGA1UEBhMCQlIxHzAdBgNVBAgTFlJpbyBHcmFuZGUgZG8gU3VsIC0gUlMx\n" \
"FTATBgNVBAcTDFBvcnRvIEFsZWdyZTE6MDgGA1UEChMxVW5pdmVyc2lkYWRlIEZl\n" \
"ZGVyYWwgZG8gUmlvIEdyYW5kZSBkbyBTdWwgLSBVRlJHUzEvMC0GA1UECxMmQ2Vu\n" \
"dHJvIGRlIFByb2Nlc3NhbWVudG8gZGUgRGFkb3MgLSBDUEQxHDAaBgNVBAMTE0FD\n" \
"IFJhaXogZGEgVUZSR1MgdjIwHhcNMTIwNDA5MTQyNTQ2WhcNMzIwNDA5MTQzNTQ1\n" \
"WjCB0DELMAkGA1UEBhMCQlIxHzAdBgNVBAgTFlJpbyBHcmFuZGUgZG8gU3VsIC0g\n" \
"UlMxFTATBgNVBAcTDFBvcnRvIEFsZWdyZTE6MDgGA1UEChMxVW5pdmVyc2lkYWRl\n" \
"IEZlZGVyYWwgZG8gUmlvIEdyYW5kZSBkbyBTdWwgLSBVRlJHUzEvMC0GA1UECxMm\n" \
"Q2VudHJvIGRlIFByb2Nlc3NhbWVudG8gZGUgRGFkb3MgLSBDUEQxHDAaBgNVBAMT\n" \
"E0FDIFJhaXogZGEgVUZSR1MgdjIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n" \
"AoIBAQDvCmjv3cCM0wZHaF7fHlFIQwbFimXNGQxMAajDaDC6QAubbRVYGuIqscoY\n" \
"8IlBgXXrFlrZVj377S9Ve5PncEh3bJeJuvIhgo2Vt6QGBiquiMqciWFtgXIFIqjn\n" \
"rZnGa3UumxMgY+jWsfM29Lk69pARdW31XyPbiVwOKZcZ/RyB01RRS2NLOvssvKaS\n" \
"XB6vXi4MJ42EoXtLV8tEFh1+ut7RzwzzsvN6rCWLE3I2cXlPBHOHdVECWgricxZA\n" \
"4Q6m9GZF3Rx0MY5Lrx8B9cCDbHRfxMVS4vzEviMrBid+S8pvd8GwliH6AXEEJZeW\n" \
"AJG1sRVCT1wTlUs21asYXJ17t1D9AgMBAAGjgdwwgdkwCwYDVR0PBAQDAgGGMA8G\n" \
"A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFPC2+TnNd301pBWHLhXqXNNStGz8MD0G\n" \
"A1UdHwQ2MDQwMqAwoC6GLGh0dHA6Ly93d3cudWZyZ3MuYnIvcGtpL0xDUkFDUmFp\n" \
"elVGUkdTdjIuY3JsMBAGCSsGAQQBgjcVAQQDAgEAMEkGCCsGAQUFBwEBBD0wOzA5\n" \
"BggrBgEFBQcwAoYtaHR0cDovL3d3dy51ZnJncy5ici9wa2kvY2VydEFDUmFpelVG\n" \
"UkdTdjIuY3J0MA0GCSqGSIb3DQEBCwUAA4IBAQBkaJBm2uNtKx9OEdUuvhT3hGLt\n" \
"lScQJfC29Vgsk7zDGEvN2xKDH8JDGsox8G9ZYsPkyNOT5TfAc334YxALq4LWZSuY\n" \
"l0xsuv4th+8qGIfZjjO1ye0/Z8paLcRLsEC+OR7S+kozsDjibLjSsWqYG04d7jvG\n" \
"W8Vhr+0yJqyGN9NiCPpRRTzvpbVpVN0scOhZpZ9vZSfbYnm04ueOEWBgybPXBZPD\n" \
"gurFALXB+uONxuNfR33T15PYLeVaaaDlXQ1krupKj9SbiKtBXghTau7ob8pCSBX4\n" \
"960mgdCu70CgA6lIFhhW3uaYifAS/h7hdOON3++dFj4FH8My1AUzwnvUtxs0\n" \
"-----END CERTIFICATE-----\n";
// You can use x.509 client certificates if you want
//const char* test_client_key = ""; //to verify the client
//const char* test_client_cert = ""; //to verify the client
/**********************************************************************************************/
char ssid[] = SECRET_SSID;
/* Idetificação rede comum */
char pass[] = SECRET_PASS;
/* Senha rede comum */
int keyIndex = 0;
/* your network key Index number (needed only for WEP) */
unsigned long myChannelNumber = SECRET_CH_ID;
/* Delcara uma variável que irá receber o número do canal utilizado pelo ThingSpeak */
const char * myWriteAPIKey = SECRET_WRITE_APIKEY;
/* Delcara uma variável que irá receber o código da chave de escrita utilizada pelo ThingSpeak */
long timezone = 1;
byte daysavetime = 1;
/*
* Verificação para checar se a versão do microcontrolador usado é compatível com a biblioteca
* SimpleTimer.h
*/
#ifndef ESP32
#error This code is designed to run on ESP32 platform, not Arduino nor ESP8266! Please check your Tools->Board setting.
#elif ( ARDUINO_ESP32S2_DEV || ARDUINO_FEATHERS2 || ARDUINO_ESP32S2_THING_PLUS || ARDUINO_MICROS2 || \
ARDUINO_METRO_ESP32S2 || ARDUINO_MAGTAG29_ESP32S2 || ARDUINO_FUNHOUSE_ESP32S2 || \
ARDUINO_ADAFRUIT_FEATHER_ESP32S2_NOPSRAM )
#define USING_ESP32_S2_TIMER_INTERRUPT true
#endif
// Configurações para timer
// These define's must be placed at the beginning before #include "ESP32TimerInterrupt.h"
// _TIMERINTERRUPT_LOGLEVEL_ from 0 to 4
// Don't define _TIMERINTERRUPT_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
// Don't define TIMER_INTERRUPT_DEBUG > 2. Only for special ISR debugging only. Can hang the system.
#define TIMER_INTERRUPT_DEBUG 0
#define _TIMERINTERRUPT_LOGLEVEL_ 0
#include "ESP32TimerInterrupt.h"
#include "ESP32_ISR_Timer.h"
#include <SimpleTimer.h> // https://github.com/jfturcot/SimpleTimer
/**********************************************************************************************/
int sel_ADC[4]={ 0x48, 0x49, 0x4A, 0x4B }, sel = 0, nR=1, pisca = 500, amostragem = 1;
/* Endreço dos conversores ADC - - ID do resistor - frequêcia do LED*/
float MFC_16i[16], MFC_8d[8];
/*Dados dos canais dos conversores ADCs - CH - DIFF*/
float ADJ_gain = 0.1875F;
/* Ajuste de ganho para ganho 1 (ONE)*/
String DATA;
/* Variavel dados enviados: data*/
String HORA;
/* Variavel dados enviados: hora*/
String TENSAO_DIFF ="CH01; CH23;";
/* Variavel dados enviados: Canal diferencial*/
String TENSAO_CH = "CH0; CH1; CH2; CH3";
/* Variavel dados enviados: Canal individual*/
String NOME_PASTA;
/* Variavel para nomeclatura: pasta*/
String NOME_TXT_INFO;
/* Variavel para nomeclatura: Arquivo de informações*/
String NOME_TXT_DIFF;
/* Variavel para nomeclatura: Arquivo de Canais diferenciais*/
String NOME_TXT_CH;
/* Variavel para nomeclatura: Arquivo de Canais individuais*/
String envio_Speak = "Nao alterado";
byte chaves = B11111111;
/* Variavel para posição inicial das chaves - Todas desligadas*/
int pos_chave[8] = { 254, 253, 251, 247, 239, 223, 191, 127};
/* Vetor para posições das chaves - Alternam entre as posições*/
/**********************************************************************************************/
#define led_pin 2
/* Led indicador definido no PORT2*/
#define CLR 32
/* Shif Resgister pin CLR definido no PORT32*/
#define A 27
/* Shif Resgister pin A definido no PORT27*/
#define B 14
/* Shif Resgister pin B definido no PORT14*/
#define CK 33
/* Shif Resgister pin CK definido no PORT33*/
#define RST 0
/* Botão de comando definido no PORT32*/
ESP32Timer ITimer(1);
/* Inicia interrupção Timer 1*/
ESP32_ISR_Timer ISR_Timer;
/* Inicia interrupação ESP*/
#define SIMPLE_TIMER_MS 60000L
/* Tempo de para ativar função de envio de dados - Tempo de amostragem*/
/**********************************************************************************************/
/* Interrupção para ESP32*/
#if USING_ESP32_S2_TIMER_INTERRUPT
void IRAM_ATTR TimerHandler(void * timerNo)
#else
void IRAM_ATTR TimerHandler()
#endif
{
#if USING_ESP32_S2_TIMER_INTERRUPT
/////////////////////////////////////////////////////////
// Always call this for ESP32-S2 before processing ISR
TIMER_ISR_START(timerNo);
/////////////////////////////////////////////////////////
#endif
#if USING_ESP32_S2_TIMER_INTERRUPT
/////////////////////////////////////////////////////////
// Always call this for ESP32-S2 after processing ISR
TIMER_ISR_END(timerNo);
/////////////////////////////////////////////////////////
#endif
}
/**********************************************************************************************/
Adafruit_ADS1115 ads;
/* Use this for the 16-bit version
* Nomeando funções ADS1015
*/
WiFiClientSecure ClientSec;
/* Habilitar quando usar rede privada (Eduroam)*/
WiFiClient client;
/* Habilitar quando usar ThingSpeak*/
SimpleTimer simpleTimer;
/* Nomeando funções SimpleTimer*/
/**********************************************************************************************/
void setup()
{
pinMode(led_pin, OUTPUT);
digitalWrite(led_pin, LOW);
/* Declara como saída digital o pino led - inicialmete desligada*/
pinMode(CLR, OUTPUT); pinMode(A, OUTPUT); pinMode(B, OUTPUT); pinMode(CK, OUTPUT);
/* Declara como saída digital o pinos para contole do Shift register - ClR, A, B, CK*/
pinMode(RST, INPUT);
/*Declara como entrada o pino RST - Botaõ integrado no módulo ESP NODE-MCU32S */
shiftOut(B, CK, LSBFIRST, chaves);
/*Inicia com os reles todos desligado */
/**********************************************************************************************/
Serial.begin(115200);
/* Inicial serial - Baud rate 115200*/
/**********************************************************************************************/
/*Quando utilizar a conexão com a rede comentar a conficuração de Wifi da para rede local/comum.*/
conecta_wifi();
/* Chama função para conecta a rede wifi */
//conecta_wifi_edu();
/* Chama função para conecta a rede wifi */
ThingSpeak.begin(client);
/* Inicia ThingSpeak */
/**********************************************************************************************/
configTime(3600*timezone, daysavetime*3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
/* Configura o horario com base no servidor*/
abre_SD ();
/* Chama a função que inicia a configuração do cartão SD*/
simpleTimer.setInterval(SIMPLE_TIMER_MS, envio_dados);
/* Configura a chamada da função no estouro do timer*/
R_rotina ();
/* Define a posição do chaveamnto dos resistores*/
shiftOut(B, CK, LSBFIRST, chaves);
/* Atualiza a posição do chaveamnto dos resistores*/
}
void loop()
{
conecta_wifi();
/* Chama função para conecta a rede wifi */
simpleTimer.run();
/* Chama a função envio_dados após o estouro do Timer*/
digitalWrite(led_pin, !digitalRead(led_pin));
delay(pisca);
/* piscs o led para verificação se não ocorreram falhas na execução da rotina*/
}
/**********************************************************************************************/
/* Função configura os módulos dos conversores ADC*/
void Inicia_MFC (int n)
{
ads.begin(sel_ADC[n]);
/* Inicializa o conversor ADC conforme a endereço - 0x48, 0x49, 0x4A, 0x4B*/
ads.setGain(GAIN_TWOTHIRDS);
/* Seta o ganho do ADC conforme faxa de operação - GAIN_TWOTHIRDS/ONE/TWO/FOUR*/
}
/* Função realiza as leituras dos módulo e canais dos conversores ADC*/
void Le_MFC ()
{
for (int i = 0; i < 2; i++)
{
Inicia_MFC (i);
/* Chama a função que inicializa o módulo 'i' módulos para ler canal Diferencial */
MFC_8d[i]=ads.readADC_Differential_0_1();
MFC_8d[i+4]=ads.readADC_Differential_2_3();
/* Grava os dados dos canais diferenciais na var. 'MFC_8d' */
}
/* Realiza a varredura dos 'n' módulos para ler canal Diferencial */
for (int i = 0; i < 2; i++){
Inicia_MFC (i);
/* Chama a função que inicializa o módulo 'i' módulos para ler canal Individual */
for (int j = 0; j < 4; j++)
MFC_16i[i*4+j]=ads.readADC_SingleEnded(j);
/* Grava os dados dos canais individuais na var. 'MFC_16i' */
}
/* Realiza a varredura dos 'n' módulos para ler canal Individual */
}
void envio_ThingSpeak (){
ThingSpeak.setField(1, MFC_8d[0]*ADJ_gain);
ThingSpeak.setField(2, MFC_8d[4]*ADJ_gain);
ThingSpeak.setField(3, MFC_8d[1]*ADJ_gain);
ThingSpeak.setField(4, MFC_8d[5]*ADJ_gain);
/*ThingSpeak.setField(5, MFC_8d[2]*ADJ_gain);
ThingSpeak.setField(6, MFC_8d[6]*ADJ_gain);
ThingSpeak.setField(7, MFC_8d[3]*ADJ_gain);
ThingSpeak.setField(8, MFC_8d[7]*ADJ_gain);
//Envio dos dados canais diferencias via ThingSpeak*/
envio_Speak = "Resistor " + String((nR-1));
/*Atualiza mensagem de envio ao ThingSpeak*/
ThingSpeak.setStatus(envio_Speak);
/*Envio mensagem ao ThingSpeak*/
int x = ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);
/*Verifica se ocrreu erro no envio ao ThingSpeak*/
if(x == 200){
Serial.println("Channel update successful.");
}
else{
Serial.println("Problem updating channel. HTTP error code " + String(x));
}
}
/* Função realiza o envio dados dados coletados via serial - realiza o backup na cartão SD*/
void envio_dados()
{
if (amostragem>=3)
{
amostragem=1;
sel=0;
/* Variavel auxiliar para troca de envio entre canais diferenciais e canais individuias */
Le_MFC ();
/* Chama função que le e grava os dados dos conversores ADC */
Serial.println(" Inicio da envio ");
/* Sinaliza o inicio do envio de dados via Serial*/
/* Verifica a troca de envio entre canais diferenciais e canais individuias */
if (sel==0)
{
save_DATA_HORA ();
/* Coleta a data e hora atual do envio*/
appendFile(SD, NOME_TXT_DIFF.c_str(), DATA.c_str());
/* Salva a data do envio no arquivo .txt das leituras diferenciais*/
appendFile(SD, NOME_TXT_DIFF.c_str(), HORA.c_str());
/* Salva a hora do envio no arquivo .txt das leituras diferenciais*/
for (int i = 0; i < 2; i++)
{
Serial.print(" ADC_"); Serial.print(i); Serial.print(" _MFC_1"); Serial.print(" ");
Serial.print(MFC_8d[i]*ADJ_gain); Serial.print(" mV "); Serial.print(" Resistor nro: "); Serial.println(nR-1);
TENSAO_DIFF = String (MFC_8d[i]*ADJ_gain) + "; ";
/* Envio dos dados canais diferencias_0_1 via Serial*/
//ThingSpeak.setField(1+i*2, MFC_8d[i]*ADJ_gain);
/* Envio dos dados canais diferencias_0_1 via ThingSpeak*/
escreve_TENSAO_DIFF ();
/* Envio dos dados canais diferencias_0_1 via Cartão SD*/
Serial.print(" ADC_"); Serial.print(i); Serial.print(" _MFC_2"); Serial.print(" ");
Serial.print(MFC_8d[i+4]*ADJ_gain);Serial.print(" mV "); Serial.print(" Resistor nro: "); Serial.println(nR-1);
TENSAO_DIFF = String (MFC_8d[i+4]*ADJ_gain) + "; ";
/* Envio dos dados canais diferencias_2_3 via Serial*/
//ThingSpeak.setField(2+i*2, MFC_8d[i+4]*ADJ_gain);
/* Envio dos dados canais diferencias_2_3 via ThingSpeak*/
escreve_TENSAO_DIFF ();
/* Envio dos dados canais diferencias_2_3 via Cartão SD*/
}
/* Fim da varredura pelo módulo dos canais doferenciais*/
appendFile(SD, NOME_TXT_DIFF.c_str(), "\n");
/* Sinaliza o fim do envio para o arquivo .txt*/
}
else
{
//save_DATA_HORA ();
/* Coleta a data e hora atual do envio*/
//appendFile(SD, NOME_TXT_CH.c_str(), DATA.c_str());
/* Salva a data do envio no arquivo .txt das leituras individuais*/
//appendFile(SD, NOME_TXT_CH.c_str(), HORA.c_str());
/* Salva a hora do envio no arquivo .txt das leituras individuais*/
//for (int i = 0; i < 8; i++)
//{
//Serial.print(" ADC_"); Serial.print(i/4); Serial.print(" _MFC_"); Serial.print(i%4);
//Serial.print(" ");
///Serial.print(MFC_16i[i]*ADJ_gain); Serial.print(" mV "); Serial.print(" Resistor nro: "); Serial.println(nR);
//TENSAO_CH = String (MFC_16i[i]*ADJ_gain) + "; ";
/* Envio dos dados canais individuais 'i' via Serial*/
//escreve_TENSAO_CH ();
/* Envio dos dados canais individuais 'i' via Cartão SD*/
//}
/* Fim da varredura pelo módulo dos canais diferenciais*/
appendFile(SD, NOME_TXT_CH.c_str(), "\n");
/* Sinaliza o fim do envio para o arquivo .txt*/
}
Serial.println(" Fim da envio ");
/* Sinaliza o inicio do envio de dados via Serial*/
envio_ThingSpeak ();
R_rotina();
/* Chama a função que realiza a rotina do experiemnto*/
shiftOut(B, CK, LSBFIRST, chaves);
/* Atualiza a posição do chaveamnto dos resistores*/
}
else {
amostragem = amostragem + 1;
}
}
/**********************************************************************************************/
/* Função que atualiza a hora e data atual*/
void save_DATA_HORA (){
struct tm tmstruct;
/* Variavel tipo struct que recebe os dados de data e hora*/
tmstruct.tm_year = 0; tmstruct.tm_mon = 0; tmstruct.tm_mday = 0;
tmstruct.tm_hour = 0; tmstruct.tm_min = 0; tmstruct.tm_sec = 0;
/* Inicia os campos com valor '0'*/
getLocalTime(&tmstruct, 5000);
/* a variavel tmstruct recebe os dados de data e hora*/
Serial.printf("\nNow is : %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct.tm_year)+1900,( tmstruct.tm_mon)+1, tmstruct.tm_mday,tmstruct.tm_hour , tmstruct.tm_min, tmstruct.tm_sec);
/*os dados de data e hora são enviado via serial*/
DATA = String((tmstruct.tm_year)+1900) + "/" + String(( tmstruct.tm_mon)+1) + "/" + String(tmstruct.tm_mday) + "; " ;
/*os dados de data são tranformados em tipo String e salvos na variavel 'DATA'*/
HORA = String(tmstruct.tm_hour) + ":" + String(tmstruct.tm_min) + ":" + String(tmstruct.tm_sec) + "; " ;
/*os dados de hora são tranformados em tipo String e salvos na variavel 'HORA'*/
Serial.println("");
/*Comando para nova linha via Serial*/
}
/* Função que atualiza o nomeia a pasta de acordo com a hora e data criada*/
void nome_PASTA () {
struct tm tmstruct;
/* Variavel tipo struct que recebe os dados de data e hora*/
tmstruct.tm_year = 0; tmstruct.tm_mon = 0; tmstruct.tm_mday = 0;
tmstruct.tm_hour = 0; tmstruct.tm_min = 0; tmstruct.tm_sec = 0;
/* Inicia os campos com valor '0'*/
getLocalTime(&tmstruct, 5000);
/* a variavel tmstruct recebe os dados de data e hora*/
NOME_PASTA = "/EXP-" + String((tmstruct.tm_year)+1900) + "-" + String(( tmstruct.tm_mon)+1) + "-" + String(tmstruct.tm_mday)+ "-" + String(tmstruct.tm_hour) + "-" + String(tmstruct.tm_min) + "-" + String(tmstruct.tm_sec);
/* Variavel cuja string irá nomear a pasta criada durante o experimento*/
}
/* Função que atualiza o nomeia os arquivos .txt de acordo com a hora e data criada*/
void nome_TXT () {
struct tm tmstruct;
/* Variavel tipo struct que recebe os dados de data e hora*/
tmstruct.tm_year = 0; tmstruct.tm_mon = 0; tmstruct.tm_mday = 0;
tmstruct.tm_hour = 0; tmstruct.tm_min = 0; tmstruct.tm_sec = 0;
/* Inicia os campos com valor '0'*/
getLocalTime(&tmstruct, 5000);
/* a variavel tmstruct recebe os dados de data e hora*/
NOME_TXT_INFO = String(NOME_PASTA) + "/INFO-" + String(tmstruct.tm_hour) + "-" + String(tmstruct.tm_min) + "-" + String(tmstruct.tm_sec) + ".txt";
/* Variavel cuja string irá nomear o arquivo .txt de informações criada durante o experimento*/
NOME_TXT_DIFF = String(NOME_PASTA) + "/v_DIFF-" + String(tmstruct.tm_hour) + "-" + String(tmstruct.tm_min) + "-" + String(tmstruct.tm_sec) + ".txt";
/* Variavel cuja string irá nomear o arquivo .txt DIFF criado durante o experimento*/
NOME_TXT_CH = String(NOME_PASTA) + "/v_CH-" + String(tmstruct.tm_hour) + "-" + String(tmstruct.tm_min) + "-" + String(tmstruct.tm_sec) + ".txt";
/* Variavel cuja string irá nomear o arquivo .txt CH criado durante o experimento*/
}
/**********************************************************************************************/
/* Função que incia o cartão SD cria e nomeia a pasta e arquivos do experimento*/
void abre_SD (){
/* Varifica se a inicialização do cartão SD fracassou*/
if(!SD.begin()){
Serial.println("Cartao SD - Nao conectado");
/* mensagem via Serial de falha na inicialização do cartão SD*/
pisca = 100;
/* Altera a frequência do Led indicando erro*/
return;
}
uint8_t cardType = SD.cardType();
/* Variavel recebe o tipo de variável*/
/* Varifica se a conexão do cartão SD fracassou*/
if(cardType == CARD_NONE){
Serial.println("Cartao SD - Nao conectado");
/* mensagem via Serial de falha na abertura do cartão SD*/
pisca = 100;
/* Altera a frequência do Led indicando erro*/
return;
}
/* Verifica o tipo de cartão SD*/
Serial.print("SD Card Type: ");
if(cardType == CARD_MMC){
Serial.println("MMC");
} else if(cardType == CARD_SD){
Serial.println("SDSC");
} else if(cardType == CARD_SDHC){
Serial.println("SDHC");
} else {
Serial.println("UNKNOWN");
}
/* Envia o tipo de cartão SD via Serial*/
uint64_t cardSize = SD.cardSize() / (1024 * 1024);
/* Variavel recebe a tamanho da memoria do cartão SD*/
Serial.printf("SD Card Size: %lluMB\n", cardSize);
/* Envia o tamanho do cartão SD via Serial*/
listDir(SD, "/", 0);
/* Envia a lista de diretorios contido no cartão SD via Serial*/
//removeDir(SD, "mydir");
/* Comando que exclui diretoris contidosn o cartão SD*/
nome_PASTA ();
nome_TXT ();
/* Cria novos nomes para pasta e arquivos com hora e data atualizadas*/
createDir(SD, NOME_PASTA.c_str());
/* Cria novas pasta e arquivos com hora e data atualizadas*/
new_Info_Geral ();
/* Chama função que cria novos arquivos .txt com o cabeçalho*/
}
/* Função que cria e nomeia a pasta e arquivos do experimento*/
void new_Info_Geral (){
writeFile (SD, NOME_TXT_INFO.c_str(), "Experimento: 01 \n");