Category Archives: Informação

ESP8266: Como enviar email pelo GMAIL.

Posted on 13 de julho de 2017 by Jefferson

O processo é muito parecido com o usado para enviar email criptografado para outros provedores. Os detalhes a atentar são:

Você precisa configurar a conta gmail para permitir o acesso de “aplicativos menos seguros”, por isso é recomendável que você crie e configure uma conta no gmail só para isso;
O servidor é smtp.gmail.com e a porta é 465;
Nos campos “MAIL from” e “RCPT to” você deve preencher apenas o email, assim: <usuario@servidor.com> . Do contrário dará “syntax error”.

Erros que você pode encontrar:

“MAIL first” – Neste momento o servidor esperava o comando “MAIL from:”
“RCPT first” – Neste momento o servidor esperava o comando “RCPT TO:”
“Syntax error” – Remova o “nome” da caixa postal. Deixe apenas o endereço de email;

Por que “aplicativos menos seguros”? Existe modo de contornar isso?

Aparentemente, não.

O gmail não parece explicar em lugar algum o que faz o aplicativo ser seguro ou não no conceito da Google. A minha suspeita é que tenha algo a ver com data/hora (para validar certificados) por duas razões:

As apps “seguras” da google também recusam seu login se, por exemplo, a data/hora do seu celular Android estiver errada;
Quando você habilita o debug “Core +SSL” do ESP8266 é exibida uma mensagem: “please start sntp first!” assim que você faz uma conexão criptografada. O autor da biblioteca, Igor, diz que essa mensagem é do SDK da Expressif e não dele e você pode “ignorá-la com segurança“, mas SNTP significa Simple Network Time Protocol e se o SDK quer que você tenha o horário correto antes da conexão, alguma razão existe.

E eu não faço idéia de como fazer o protocolo de comunicação ser configurado com data/hora corretos nem se isso seria suficiente. A Google possivelmente quer se certificar de que você está validando o certificado dela antes de transmitir, mas isso é só um palpite.

Postado em Informação | Tags: email, ESP8266 | Deixe um comentário

ESP8266: Como enviar e-mail por uma conexão criptografada (SSL/TLS).

Posted on 12 de julho de 2017 by Jefferson

Em um post anterior eu mostrei como se enviava e-mail e adverti para o fato de que a conexão não era segura e as credenciais podiam ser interceptadas (além do fato óbvio do e-mail poder ser lido). Eu achei que enviar por uma conexão segura fosse muito complicado, mas descobri que não é. O problema é que usa muita RAM. O email sem criptografia te deixa com 46KB livres para o resto do seu programa enquanto este aqui te deixa com “apenas” 18KB. Lembre-se de que isso ainda é 9x a RAM total de um Arduino UNO.

Sobre fingerprints e validação de certificado

Se você usa um servidor de e-mail numa conta compartilhada, como é o caso da hostgator, o certificado não vai validar se você colocar o nome do seu domínio como servidor. Você tem que obter o nome correto do servidor de e-mail que atende a sua conta. Na hostgator isso pode ser visto no cPanel.

Por exemplo, meu servidor de e-mail normal seria: meudominio.com.br ou mail.meudominio.com.br mas para validar o certificado eu preciso colocar gator1234.hostgator.com.

O exemplo abaixo é uma adaptação simples do exemplo que não usa criptografia.

/*
 *  Envio de e-mail por SMTP usando conexão criptografada
 *  Jefferson Ryan - automalabs.com.br - Julho de 2017
 *  Testado em um ESP8266 - ESP-01 - IDE Arduino 1.8.1 e ESP8266 Core v2.3.0
 *  Mais informações em http://www.automalabs.com.br/?p=1595
 *  
 */
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

//======== Você precisa preencher estes dados ===========================================
const char* SSID = "";
const char* PASS = "";

char smtp_server[] = "";
const int smtp_port = 465; //465 é a porta segura no meu servidor. A sua pode ser outra.
const String mail_username="nome_do_usuario";
const String mail_password="senha";
const String mail_from="ESP8266 <usuario@servidor_remetente>";
const String mail_to="Jefferson <usuario@servidor_destino>";
const String mail_subject="Enviado pelo ESP8266";
const String mail_line1="Esta é a linha 1\n";
const String mail_line2="Esta é a linha 2";
const String mail_line3="Esta é a linha 3";

//Obtenha com a ajuda de https://www.grc.com/fingerprints.htm
//Precisará ser atualizado manualmente quando o certificado expirar
const char* fingerprint = "";
//=========================================================================================

bool construindoLinha=false;
const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Cria uma conexao SSL/TLS
WiFiClientSecure client;

void printFreeRAM(){
  Serial.print("RAM livre: ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" bytes.");
}

void a3_to_a4(unsigned char * a4, unsigned char * a3) {
  a4[0] = (a3[0] & 0xfc) >> 2;
  a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
  a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
  a4[3] = (a3[2] & 0x3f);
}

int base64_encode(char *output, const char *input, int inputLen) {
  int i = 0, j = 0;
  int encLen = 0;
  unsigned char a3[3];
  unsigned char a4[4];
  while(inputLen--) {
    a3[i++] = *(input++);
    if(i == 3) {
      a3_to_a4(a4, a3);
      for(i = 0; i < 4; i++) {
        output[encLen++] = _b64_alphabet[a4[i]];
      }
      i = 0;
    }
  }
  if(i) {
    for(j = i; j < 3; j++) {
      a3[j] = '\0';
    }
    a3_to_a4(a4, a3);
    for(j = 0; j < i + 1; j++) {
      output[encLen++] = _b64_alphabet[a4[j]];
    }
    while((i++ < 3)) {
      output[encLen++] = '=';
    }
  }
  output[encLen] = '\0';
  return encLen;
}

void setup()
{
  Serial.begin(115200);
 // Serial.setDebugOutput(true);
  delay(10);
  Serial.println("");
  Serial.println("");
  Serial.print("Conectando a: ");
  Serial.println(SSID);
  Serial.print("Com a senha: ");
  Serial.println(PASS);
  WiFi.begin(SSID, PASS);

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Conectado.");
  Serial.print("Endereco IP local: ");
  Serial.println(WiFi.localIP());
  printFreeRAM();
  byte ret = sendEmail();
  printFreeRAM();
}

void loop()
{
}

void SEND(String message)
{
if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
Serial.print (message);
client.print (message);
construindoLinha=true;
  
}

void SENDln(String message)
{
if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
Serial.println (message);
client.println (message);
construindoLinha=false;  
}

byte sendEmail()
{
  byte thisByte = 0;
  byte respCode;

  Serial.print("Conectando a: ");
  Serial.println(smtp_server);
  if (!client.connect(smtp_server, smtp_port)) {
    Serial.println("Falha na conexao.");
    return 0;
  }else
  {
    Serial.println("Conectado.");
  }

  if (client.verify(fingerprint,smtp_server)) {
    Serial.println("O certificado confere.");
  } else {
    Serial.println("O certificado nao confere.");
    //return 0; //Descomente esta linha para impedir o envio se o certificado estiver errado
  }


  if (!eRcv()) return 0;

  char* buf = (char*)malloc(100);

  SEND("EHLO ");
  SENDln(smtp_server); 
  if (!eRcv()) return 0;

  SENDln("auth login");
  if (!eRcv()) return 0;

  base64_encode(buf, mail_username.c_str(), mail_username.length());
  client.println(buf);  
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  base64_encode(buf, mail_password.c_str(), mail_password.length());
  client.println(buf);   
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  SEND("MAIL From: ");
  SENDln(mail_from);
  if (!eRcv()) return 0;
  
  SEND("RCPT To: ");
  SENDln(mail_to);
  if (!eRcv()) return 0;
  
  SENDln("DATA");
  if (!eRcv()) return 0;
  
  SEND("To: ");
  SENDln(mail_to);
  SEND("From: "); 
  SENDln(mail_from); //Este é o "nome para exibição"
  SEND("Subject: ");
  SENDln(mail_subject);
  SENDln(mail_line1);
  SENDln(mail_line2);
  SENDln(mail_line3);
  SENDln("."); //O email tem que terminar assim
  if (!eRcv()) return 0;

  SENDln("QUIT");
 
  if (!eRcv()) return 0;
  client.stop();
  Serial.println("Desconectado.");
  return 1;
}

byte eRcv()
{
  byte respCode;
  byte thisByte;
  int loopCount = 0;

  while (!client.available()) {
    delay(1);
    loopCount++;
    // Se nada for recebido em 10s, desiste.
    if (loopCount > 10000) {
      client.stop();
      Serial.println("\r\nTimeout");
      return 0;
    }
  }

  respCode = client.peek();
  while (client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);
  }

  if (respCode >= '4')
  {
    //  efail();
    return 0;
  }
  return 1;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

* Envio de e-mail por SMTP usando conexão criptografada

* Jefferson Ryan - automalabs.com.br - Julho de 2017

* Testado em um ESP8266 - ESP-01 - IDE Arduino 1.8.1 e ESP8266 Core v2.3.0

* Mais informações em http://www.automalabs.com.br/?p=1595

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

//======== Você precisa preencher estes dados ===========================================

const char* SSID = "";

const char* PASS = "";

char smtp_server[] = "";

const int smtp_port = 465; //465 é a porta segura no meu servidor. A sua pode ser outra.

const String mail_username="nome_do_usuario";

const String mail_password="senha";

const String mail_from="ESP8266 <usuario@servidor_remetente>";

const String mail_to="Jefferson <usuario@servidor_destino>";

const String mail_subject="Enviado pelo ESP8266";

const String mail_line1="Esta é a linha 1\n";

const String mail_line2="Esta é a linha 2";

const String mail_line3="Esta é a linha 3";

//Obtenha com a ajuda de https://www.grc.com/fingerprints.htm

//Precisará ser atualizado manualmente quando o certificado expirar

const char* fingerprint = "";

//=========================================================================================

bool construindoLinha=false;

const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Cria uma conexao SSL/TLS

WiFiClientSecure client;

void printFreeRAM(){

Serial.print("RAM livre: ");

Serial.print(ESP.getFreeHeap());

Serial.println(" bytes.");

}

void a3_to_a4(unsigned char * a4, unsigned char * a3) {

a4[0] = (a3[0] & 0xfc) >> 2;

a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);

a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);

a4[3] = (a3[2] & 0x3f);

}

int base64_encode(char *output, const char *input, int inputLen) {

int i = 0, j = 0;

int encLen = 0;

unsigned char a3[3];

unsigned char a4[4];

while(inputLen--) {

a3[i++] = *(input++);

if(i == 3) {

a3_to_a4(a4, a3);

for(i = 0; i < 4; i++) {

output[encLen++] = _b64_alphabet[a4[i]];

}

i = 0;

}

if(i) {

for(j = i; j < 3; j++) {

a3[j] = '\0';

}

a3_to_a4(a4, a3);

for(j = 0; j < i + 1; j++) {

output[encLen++] = _b64_alphabet[a4[j]];

}

while((i++ < 3)) {

output[encLen++] = '=';

}

output[encLen] = '\0';

return encLen;

}

void setup()

{

Serial.begin(115200);

// Serial.setDebugOutput(true);

delay(10);

Serial.println("");

Serial.print("Conectando a: ");

Serial.println(SSID);

Serial.print("Com a senha: ");

Serial.println(PASS);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED)

{

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi Conectado.");

Serial.print("Endereco IP local: ");

Serial.println(WiFi.localIP());

printFreeRAM();

byte ret = sendEmail();

printFreeRAM();

}

void loop()

{

}

void SEND(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.print (message);

client.print (message);

construindoLinha=true;

}

void SENDln(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.println (message);

client.println (message);

construindoLinha=false;

}

byte sendEmail()

{

byte thisByte = 0;

byte respCode;

Serial.print("Conectando a: ");

Serial.println(smtp_server);

if (!client.connect(smtp_server, smtp_port)) {

Serial.println("Falha na conexao.");

return 0;

}else

{

Serial.println("Conectado.");

}

if (client.verify(fingerprint,smtp_server)) {

Serial.println("O certificado confere.");

} else {

Serial.println("O certificado nao confere.");

//return 0; //Descomente esta linha para impedir o envio se o certificado estiver errado

}

if (!eRcv()) return 0;

char* buf = (char*)malloc(100);

SEND("EHLO ");

SENDln(smtp_server);

if (!eRcv()) return 0;

SENDln("auth login");

if (!eRcv()) return 0;

base64_encode(buf, mail_username.c_str(), mail_username.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

base64_encode(buf, mail_password.c_str(), mail_password.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

SEND("MAIL From: ");

SENDln(mail_from);

if (!eRcv()) return 0;

SEND("RCPT To: ");

SENDln(mail_to);

if (!eRcv()) return 0;

SENDln("DATA");

if (!eRcv()) return 0;

SEND("To: ");

SENDln(mail_to);

SEND("From: ");

SENDln(mail_from); //Este é o "nome para exibição"

SEND("Subject: ");

SENDln(mail_subject);

SENDln(mail_line1);

SENDln(mail_line2);

SENDln(mail_line3);

SENDln("."); //O email tem que terminar assim

if (!eRcv()) return 0;

SENDln("QUIT");

if (!eRcv()) return 0;

client.stop();

Serial.println("Desconectado.");

return 1;

}

byte eRcv()

{

byte respCode;

byte thisByte;

int loopCount = 0;

while (!client.available()) {

delay(1);

loopCount++;

// Se nada for recebido em 10s, desiste.

if (loopCount > 10000) {

client.stop();

Serial.println("\r\nTimeout");

return 0;

}

respCode = client.peek();

while (client.available())

{

thisByte = client.read();

Serial.write(thisByte);

}

if (respCode >= '4')

{

// efail();

return 0;

}

return 1;

}

Por alto, as diferenças são 4:

1)Acrescente: #include <WiFiClientSecure.h>

2)Acrescente: const char* fingerprint = “fingerprint_aqui”;

3)Mude: WiFiClient client; para WiFiClientSecure client;

4)Acrescente a validação de certificado logo após a conexão:

  if (client.verify(fingerprint,smtp_server)) {
    Serial.println("O certificado confere.");
  } else {
    Serial.println("O certificado nao confere.");
    //return 0; //Descomente esta linha para impedir o envio se o certificado estiver errado
  }

if (client.verify(fingerprint,smtp_server)) {

Serial.println("O certificado confere.");

} else {

Serial.println("O certificado nao confere.");

//return 0; //Descomente esta linha para impedir o envio se o certificado estiver errado

}

Postado em Informação | Tags: email, ESP8266 | 3 Comments

ESP8266: Os LEDs do módulo ESP-01

Posted on 12 de julho de 2017 by Jefferson

ESP-01_leds

O LED vermelho é ligado diretamente à alimentação e o LED azul é ligado ao TX da serial. Se você não usar a serial no seu projeto pode controlar esse LED usando GPIO1, conforme o código abaixo:

/* Blink the blue LED on the ESP-01 module
 Based on Blink without Delay. This example code is in the public domain
 http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
 */

const int ledPin =  1;  // The blue LED on the ESP-01 module is connected to GPIO1 
                        // (which is also the TXD pin; so we cannot user Serial at the same time

int ledState = LOW;     

unsigned long previousMillis = 0;
const long interval = 1000;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;   
    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;
    digitalWrite(ledPin, ledState);
  }
}

/* Blink the blue LED on the ESP-01 module

Based on Blink without Delay. This example code is in the public domain

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

const int ledPin = 1; // The blue LED on the ESP-01 module is connected to GPIO1

// (which is also the TXD pin; so we cannot user Serial at the same time

int ledState = LOW;

unsigned long previousMillis = 0;

const long interval = 1000;

void setup() {

pinMode(ledPin, OUTPUT);

}

void loop()

{

unsigned long currentMillis = millis();

if(currentMillis - previousMillis >= interval) {

previousMillis = currentMillis;

if (ledState == LOW)

ledState = HIGH;

else

ledState = LOW;

digitalWrite(ledPin, ledState);

}

Postado em Informação | Tags: ESP8266 | Deixe um comentário

ESP8266: GPIO no módulo ESP-01

Posted on 11 de julho de 2017 by Jefferson

esp8266_esp01_automalabs

ESP-01_pinout_automalabs

O problema: o ESP-01 tem apenas dois GPIO disponíveis: GPIO0 e GPIO2 e ambos são usados no processo de boot do chip.

Por que é tão limitado ?

O meu melhor palpite é que ele não foi mesmo feito para isso. Quando o ESP-01 surgiu não existia essa facilidade que temos hoje para programá-lo diretamente. O fabricante do módulo, AI Thinker, criou um firmware que respondia a comandos AT e esse módulo foi criado para basicamente dar Wi-Fi a um projeto usando outro microcontrolador, como um Arduino. O módulo não precisava de GPIO para isso e o microcontrolador podia se comunicar por TX e RX e controlar seu status e até resetá-lo através dos pinos RST e CH_PD.

Para usar como saídas

Qualquer que seja o caso é recomendável que você tenha resistores de pull-up em ambos e assim o sinal ativo seja “LOW”.

Você pode usar ambos GPIO0 e GPIO2 como saídas, mas eu só recomendo no momento para LEDs e para i2C. GPIO2 especificamente é o TX da “hardware UART” na inicialização e por isso “pisca”. Acionar um relê com ele pode não ser uma boa ideia. GPIO0 parece ser seguro para relês mas ainda não estou certo disso.

Eu costumo usar assim e até agora não notei nenhum problema. Alguns recomendam colocar um pull-up de 4k7 ou 3k3 em paralelo com cada conjunto, mas ainda não vi real necessidade para isso:

ESP-01_output_leds

Para usar como entrada

Se qualquer um dos dois pinos estiver em nível baixo o ESP8266 poderá não inicializar. Você pode contornar o problema usando um dos GPIO como saída para ativar o uso do outro como entrada conforme mostra o último exemplo desta página, que é muito confuso por isso refiz assim:

ESP-01_GPIO

Durante o boot não importa se a chave S1 está aberta ou fechada, os resistores manterão GPIO0 e GPIO2 em nível alto. Quando rodar o programa você coloca GPIO2 como saída e em nível baixo, assim:

pinMode(2, OUTPUT);
digitalWrite(2, LOW);

Agora GPIO0 pode ser HIGH ou LOW dependendo da posição da chave. E assim você ganha uma entrada.

Mas o modo mais simples e “seguro” de ter uma entrada no ESP-01 é usar o pino RX da serial. Ele pode ser “liberado” no sketch com uma linha assim:

Serial.begin(115200,SERIAL_8N1,SERIAL_TX_ONLY);

É claro que você não vai poder transmitir nada para esse sketch, mas vai poder receber normalmente pela serial.

Outro modo, mais complicado, de expandir a capacidade de I/O do ESP-01 é usando i2C. Basta um chip como o PCF8574 para transformar GPIO0 e GPIO2 em até oito entradas/saídas perfeitamente usáveis.

ESP-01_PCF8574_I2C

Postado em Informação | Tags: ESP8266 | 2 Comments

ESP8266: Como enviar notificações usando o serviço Pushbullet

Posted on 11 de julho de 2017 by Jefferson

O Pushbullet é um serviço muito útil que permite enviar notificações instantâneas com o texto que você quiser para smartphones, tablets, browsers, etc. Antes de usar este exemplo certifique-se de que o serviço Pushbullet funciona para você usando o que está explicado neste outro post.

Este exemplo foi baseado neste aqui que por sua vez é baseado no exemplo HTTPSRequest.ino da biblioteca. Eu incluí algumas modificações que gosto de fazer.

Não tem checagens de erro, mas por sem bem simples fica também simples de entender.

Note que por usar HTTPS requer muita RAM. Eu incluí uma função para mostrar o impacto disso.

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

// ============= Você precisa preencher com seus dados ===================================
const char* ssid = "";
const char* password = "";

const char* PushBulletAPIKEY = ""; //A sua chave de API. Veja na sua conta Pushbullet.
const String message_title = "Enviado do ESP8266";
const String message_body = "Funciona!";

// ========================================================================================

const char* host = "api.pushbullet.com";
const int httpsPort = 443;
//Tenha em mente que este fingerprint muda toda vez que a Pusnbullet renovar seu certificado
const char* fingerprint = "E7 06 F1 30 B1 5F 25 72 00 4D 99 F0 ED 90 4D F9 60 D3 FB 75"; 

void printFreeRAM(){
  Serial.print("RAM livre: ");
  Serial.print(ESP.getFreeHeap());
  Serial.print(" bytes.");
  
}


void setup() {
  Serial.begin(115200);
  //Serial.setDebugOutput(true);  
  printFreeRAM();
  WiFi.mode(WIFI_STA); //Apenas para me certificar de que o AP não seja ativado por uma configuração anterior gravada na flash  
  Serial.println();
  Serial.print("Conectando a: ");
  Serial.println(ssid);
  Serial.print("Com a senha: ");
  Serial.println(password);  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi conetado.");
  Serial.println("Endereco IP do modulo: ");
  Serial.println(WiFi.localIP());

  // Use WiFiClientSecure class to create TLS connection
  WiFiClientSecure client;
  Serial.print("Conectando a: ");
  Serial.println(host);
  if (!client.connect(host, httpsPort)) {
    Serial.println("Falha na conexao.");
    return;
  }

  if (client.verify(fingerprint, host)) {
    Serial.println("O certificado confere.");
  } else {
    Serial.println("O certificado não confere.");
  }

 printFreeRAM(); //A RAM livre cai uns 20KB neste ponto.

   Serial.println("Enviando POST.");
  
  String url = "/v2/pushes";
  String messagebody = "{\"type\": \"note\", \"title\": \""+message_title+"\", \"body\": \""+message_body+"\"}\r\n";
  Serial.print("requesting URL: ");
  Serial.println(url);

  client.print(String("POST ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "Authorization: Bearer " + PushBulletAPIKEY + "\r\n" +
               "Content-Type: application/json\r\n" +
               "Content-Length: " +
               String(messagebody.length()) + "\r\n\r\n");
  client.print(messagebody);


  Serial.println("Esperando resposta.");

  while (client.available() == 0);

  while (client.available()) {
    String line = client.readStringUntil('\n');
    Serial.println(line);
  }
}

void loop() {
}

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

// ============= Você precisa preencher com seus dados ===================================

const char* ssid = "";

const char* password = "";

const char* PushBulletAPIKEY = ""; //A sua chave de API. Veja na sua conta Pushbullet.

const String message_title = "Enviado do ESP8266";

const String message_body = "Funciona!";

// ========================================================================================

const char* host = "api.pushbullet.com";

const int httpsPort = 443;

//Tenha em mente que este fingerprint muda toda vez que a Pusnbullet renovar seu certificado

const char* fingerprint = "E7 06 F1 30 B1 5F 25 72 00 4D 99 F0 ED 90 4D F9 60 D3 FB 75";

void printFreeRAM(){

Serial.print("RAM livre: ");

Serial.print(ESP.getFreeHeap());

Serial.print(" bytes.");

}

void setup() {

Serial.begin(115200);

//Serial.setDebugOutput(true);

printFreeRAM();

WiFi.mode(WIFI_STA); //Apenas para me certificar de que o AP não seja ativado por uma configuração anterior gravada na flash

Serial.println();

Serial.print("Conectando a: ");

Serial.println(ssid);

Serial.print("Com a senha: ");

Serial.println(password);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi conetado.");

Serial.println("Endereco IP do modulo: ");

Serial.println(WiFi.localIP());

// Use WiFiClientSecure class to create TLS connection

WiFiClientSecure client;

Serial.print("Conectando a: ");

Serial.println(host);

if (!client.connect(host, httpsPort)) {

Serial.println("Falha na conexao.");

return;

}

if (client.verify(fingerprint, host)) {

Serial.println("O certificado confere.");

} else {

Serial.println("O certificado não confere.");

}

printFreeRAM(); //A RAM livre cai uns 20KB neste ponto.

Serial.println("Enviando POST.");

String url = "/v2/pushes";

String messagebody = "{\"type\": \"note\", \"title\": \""+message_title+"\", \"body\": \""+message_body+"\"}\r\n";

Serial.print("requesting URL: ");

Serial.println(url);

client.print(String("POST ") + url + " HTTP/1.1\r\n" +

"Host: " + host + "\r\n" +

"Authorization: Bearer " + PushBulletAPIKEY + "\r\n" +

"Content-Type: application/json\r\n" +

"Content-Length: " +

String(messagebody.length()) + "\r\n\r\n");

client.print(messagebody);

Serial.println("Esperando resposta.");

while (client.available() == 0);

while (client.available()) {

String line = client.readStringUntil('\n');

Serial.println(line);

}

void loop() {

}

Postado em Informação | Tags: ESP8266 | Deixe um comentário

ESP8266: Como enviar um e-mail a cada x minutos em caso de alarme.

Posted on 11 de julho de 2017 by Jefferson

Este exemplo é uma aplicação desse.

Está configurado para mandar dois e-mails diferentes para um mesmo destinatário. Um quando a condição for ativada (repetindo a cada x minutos) e outro quando for desativada.

Para criar uma versão com criptografia, veja instruções neste post.

/*
 * Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas
 * Use uma conta de email descartável. E não use para nada que seja sigiloso.
 * Jefferson Ryan - automalabs.com.br - julho 2017
 *  
 */

 
#include <Ticker.h>
#include <ESP8266WiFi.h>

// itens a preencher ================================================
// Configure o resto em AlarmeON() e AlarmeOFF() 
const char* SSID = "";
const char* PASS = "";
char smtp_server[] = "exemplo.com.br";
//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia
const int smtp_port = 587; //pode ser 25, 2525 587, 465, etc. Veja com seu provedor de email.
const String mail_username="usuario@exemplo.com.br";
const String mail_password="senha";
const String mail_from="ESP8266 <remetente@servidor_remetente>";
const String mail_to="Jefferson <destinatario@servidor_destinatario>";
String mail_subject=""; //Preencha em AlarmeON() e AlarmeOFF()
String mail_line1=""; //Preencha em AlarmeON() e AlarmeOFF()
String mail_line2=""; //Preencha em AlarmeON() e AlarmeOFF()
String mail_line3=""; //Preencha em AlarmeON() e AlarmeOFF()

const int sensorPin = 0; //0=GPIO zero
const int intervalo=15; //em minutos
//=====================================================================


bool alarmando = false;
bool refresh=false;
bool construindoLinha=false;
const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;
Ticker tick;


void a3_to_a4(unsigned char * a4, unsigned char * a3) {
  a4[0] = (a3[0] & 0xfc) >> 2;
  a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
  a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
  a4[3] = (a3[2] & 0x3f);
}

int base64_encode(char *output, const char *input, int inputLen) {
  int i = 0, j = 0;
  int encLen = 0;
  unsigned char a3[3];
  unsigned char a4[4];
  while(inputLen--) {
    a3[i++] = *(input++);
    if(i == 3) {
      a3_to_a4(a4, a3);
      for(i = 0; i < 4; i++) {
        output[encLen++] = _b64_alphabet[a4[i]];
      }
      i = 0;
    }
  }
  if(i) {
    for(j = i; j < 3; j++) {
      a3[j] = '\0';
    }
    a3_to_a4(a4, a3);
    for(j = 0; j < i + 1; j++) {
      output[encLen++] = _b64_alphabet[a4[j]];
    }
    while((i++ < 3)) {
      output[encLen++] = '=';
    }
  }
  output[encLen] = '\0';
  return encLen;
}

void setup()
{
  pinMode(sensorPin, INPUT);  

  Serial.begin(115200);
  delay(10);
  Serial.println("");
  Serial.println("");
  Serial.print("Conectando a: ");
  Serial.println(SSID);
  Serial.print("Com a senha: ");
  Serial.println(PASS);  
  WiFi.begin(SSID, PASS);

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Conectado.");
  Serial.print("Endereco IP: ");
  Serial.println(WiFi.localIP());

 Serial.print("A cada ");
 Serial.print(intervalo);
 Serial.print(" segundos sera enviado um email se GPIO ");
 Serial.print(sensorPin);
 Serial.println(" estiver em nível baixo.");
}

void fimContagem()
{
  //fimContagem é uma callback do Ticker e a documentação recomenda não fazer nada
  //"blocking" aqui. Na dúvida é melhor só levantar uma flag e processar no loop
  refresh=true;
}


void loop()
{

 if (refresh) { //Ocorre apenas a cada x segundos
   if (digitalRead(sensorPin)==LOW){
    alarmeON(); 

   }
   refresh=false;
 }

    if ((digitalRead(sensorPin)==HIGH)&&(alarmando)){ //Executa uma única vez e imediatamente ao mudar de estado 
    alarmeOFF(); 

   }

    if ((digitalRead(sensorPin)==LOW)&&(!alarmando)){ //Executa uma única vez e imediatamente ao mudar de estado 
    alarmeON(); 

   }   

}


void alarmeOFF()
{
  Serial.println("\r\nDesligando.\r\n");
  tick.detach();//paro a contagem de tempo
     alarmando=false; 
     mail_subject="Alarme OFF!";
     mail_line1="Esta é a linha 1\n";
     mail_line2="Esta é a linha 2";
     mail_line3="Esta é a linha 3";   
     byte ret = sendEmail(); 
  
} 


void alarmeON()
{
    Serial.println("\r\nLigando.\r\n");
    tick.attach(intervalo*60, fimContagem); //A partir deste momnento, executa "fimContagem" a cada intervalo    
     alarmando=true; 
     mail_subject="Alarme ON!";
     mail_line1="Esta é a linha 1\n";
     mail_line2="Esta é a linha 2";
     mail_line3="Esta é a linha 3";   
     byte ret = sendEmail(); 
  
} 
  

void SEND(String message)
{
  if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
  Serial.print (message);
  client.print (message);
  construindoLinha=true;
  
}

void SENDln(String message)
{
  if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
  Serial.println (message);
  client.println (message);
  construindoLinha=false;  
}

byte sendEmail()
{
  byte thisByte = 0;
  byte respCode;

  Serial.print("Conectando a ");
  Serial.println(smtp_server);
  if (client.connect(smtp_server, smtp_port) == 1) {
    Serial.println("Conectado.");
  } else {
    Serial.println("Falha na conexao.");
    return 0;
  }
  if (!eRcv()) return 0;

  char* buf = (char*)malloc(100);

  SEND("EHLO ");
  SENDln(smtp_server); 
  if (!eRcv()) return 0;

  SENDln("auth login");
  if (!eRcv()) return 0;

  base64_encode(buf, mail_username.c_str(), mail_username.length());
  client.println(buf);  
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  base64_encode(buf, mail_password.c_str(), mail_password.length());
  client.println(buf);   
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  SEND("MAIL From: ");
  SENDln(mail_from);
  if (!eRcv()) return 0;
  
  SEND("RCPT To: ");
  SENDln(mail_to);
  if (!eRcv()) return 0;
  
  SENDln("DATA");
  if (!eRcv()) return 0;
  
  SEND("To: ");
  SENDln(mail_to);
  SEND("From: "); 
  SENDln(mail_from); //Este é o "nome para exibição"
  SEND("Subject: ");
  SENDln(mail_subject);
  SENDln(mail_line1);
  SENDln(mail_line2);
  SENDln(mail_line3);
  SENDln("."); //O email tem que terminar assim
  if (!eRcv()) return 0;

  SENDln("QUIT");
 
  if (!eRcv()) return 0;
  client.stop();
  Serial.println("Desconectado.");
  return 1;
}

byte eRcv()
{
  byte respCode;
  byte thisByte;
  int loopCount = 0;

  while (!client.available()) {
    delay(1);
    loopCount++;
    // if nothing received for 10 seconds, timeout
    if (loopCount > 10000) {
      client.stop();
      Serial.println("\r\nTimeout");
      return 0;
    }
  }

  respCode = client.peek();
  while (client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);
  }

  if (respCode >= '4')
  {
    //  efail();
    return 0;
  }
  return 1;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

* Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas

* Use uma conta de email descartável. E não use para nada que seja sigiloso.

* Jefferson Ryan - automalabs.com.br - julho 2017

#include <Ticker.h>

#include <ESP8266WiFi.h>

// itens a preencher ================================================

// Configure o resto em AlarmeON() e AlarmeOFF()

const char* SSID = "";

const char* PASS = "";

char smtp_server[] = "exemplo.com.br";

//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia

const int smtp_port = 587; //pode ser 25, 2525 587, 465, etc. Veja com seu provedor de email.

const String mail_username="usuario@exemplo.com.br";

const String mail_password="senha";

const String mail_from="ESP8266 <remetente@servidor_remetente>";

const String mail_to="Jefferson <destinatario@servidor_destinatario>";

String mail_subject=""; //Preencha em AlarmeON() e AlarmeOFF()

String mail_line1=""; //Preencha em AlarmeON() e AlarmeOFF()

String mail_line2=""; //Preencha em AlarmeON() e AlarmeOFF()

String mail_line3=""; //Preencha em AlarmeON() e AlarmeOFF()

const int sensorPin = 0; //0=GPIO zero

const int intervalo=15; //em minutos

//=====================================================================

bool alarmando = false;

bool refresh=false;

bool construindoLinha=false;

const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;

Ticker tick;

void a3_to_a4(unsigned char * a4, unsigned char * a3) {

a4[0] = (a3[0] & 0xfc) >> 2;

a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);

a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);

a4[3] = (a3[2] & 0x3f);

}

int base64_encode(char *output, const char *input, int inputLen) {

int i = 0, j = 0;

int encLen = 0;

unsigned char a3[3];

unsigned char a4[4];

while(inputLen--) {

a3[i++] = *(input++);

if(i == 3) {

a3_to_a4(a4, a3);

for(i = 0; i < 4; i++) {

output[encLen++] = _b64_alphabet[a4[i]];

}

i = 0;

}

if(i) {

for(j = i; j < 3; j++) {

a3[j] = '\0';

}

a3_to_a4(a4, a3);

for(j = 0; j < i + 1; j++) {

output[encLen++] = _b64_alphabet[a4[j]];

}

while((i++ < 3)) {

output[encLen++] = '=';

}

output[encLen] = '\0';

return encLen;

}

void setup()

{

pinMode(sensorPin, INPUT);

Serial.begin(115200);

delay(10);

Serial.println("");

Serial.print("Conectando a: ");

Serial.println(SSID);

Serial.print("Com a senha: ");

Serial.println(PASS);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED)

{

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi Conectado.");

Serial.print("Endereco IP: ");

Serial.println(WiFi.localIP());

Serial.print("A cada ");

Serial.print(intervalo);

Serial.print(" segundos sera enviado um email se GPIO ");

Serial.print(sensorPin);

Serial.println(" estiver em nível baixo.");

}

void fimContagem()

{

//fimContagem é uma callback do Ticker e a documentação recomenda não fazer nada

//"blocking" aqui. Na dúvida é melhor só levantar uma flag e processar no loop

refresh=true;

}

void loop()

{

if (refresh) { //Ocorre apenas a cada x segundos

if (digitalRead(sensorPin)==LOW){

alarmeON();

}

refresh=false;

}

if ((digitalRead(sensorPin)==HIGH)&&(alarmando)){ //Executa uma única vez e imediatamente ao mudar de estado

alarmeOFF();

}

if ((digitalRead(sensorPin)==LOW)&&(!alarmando)){ //Executa uma única vez e imediatamente ao mudar de estado

alarmeON();

}

void alarmeOFF()

{

Serial.println("\r\nDesligando.\r\n");

tick.detach();//paro a contagem de tempo

alarmando=false;

mail_subject="Alarme OFF!";

mail_line1="Esta é a linha 1\n";

mail_line2="Esta é a linha 2";

mail_line3="Esta é a linha 3";

byte ret = sendEmail();

}

void alarmeON()

{

Serial.println("\r\nLigando.\r\n");

tick.attach(intervalo*60, fimContagem); //A partir deste momnento, executa "fimContagem" a cada intervalo

alarmando=true;

mail_subject="Alarme ON!";

mail_line1="Esta é a linha 1\n";

mail_line2="Esta é a linha 2";

mail_line3="Esta é a linha 3";

byte ret = sendEmail();

}

void SEND(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.print (message);

client.print (message);

construindoLinha=true;

}

void SENDln(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.println (message);

client.println (message);

construindoLinha=false;

}

byte sendEmail()

{

byte thisByte = 0;

byte respCode;

Serial.print("Conectando a ");

Serial.println(smtp_server);

if (client.connect(smtp_server, smtp_port) == 1) {

Serial.println("Conectado.");

} else {

Serial.println("Falha na conexao.");

return 0;

}

if (!eRcv()) return 0;

char* buf = (char*)malloc(100);

SEND("EHLO ");

SENDln(smtp_server);

if (!eRcv()) return 0;

SENDln("auth login");

if (!eRcv()) return 0;

base64_encode(buf, mail_username.c_str(), mail_username.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

base64_encode(buf, mail_password.c_str(), mail_password.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

SEND("MAIL From: ");

SENDln(mail_from);

if (!eRcv()) return 0;

SEND("RCPT To: ");

SENDln(mail_to);

if (!eRcv()) return 0;

SENDln("DATA");

if (!eRcv()) return 0;

SEND("To: ");

SENDln(mail_to);

SEND("From: ");

SENDln(mail_from); //Este é o "nome para exibição"

SEND("Subject: ");

SENDln(mail_subject);

SENDln(mail_line1);

SENDln(mail_line2);

SENDln(mail_line3);

SENDln("."); //O email tem que terminar assim

if (!eRcv()) return 0;

SENDln("QUIT");

if (!eRcv()) return 0;

client.stop();

Serial.println("Desconectado.");

return 1;

}

byte eRcv()

{

byte respCode;

byte thisByte;

int loopCount = 0;

while (!client.available()) {

delay(1);

loopCount++;

// if nothing received for 10 seconds, timeout

if (loopCount > 10000) {

client.stop();

Serial.println("\r\nTimeout");

return 0;

}

respCode = client.peek();

while (client.available())

{

thisByte = client.read();

Serial.write(thisByte);

}

if (respCode >= '4')

{

// efail();

return 0;

}

return 1;

}

Postado em Informação | Tags: ESP8266 | 4 Comments

ESP8266: Como enviar e-mail por um servidor SMTP

Posted on 10 de julho de 2017 by Jefferson

Para a versão que usa SSL/TLS, veja este post.

Este código é um aperfeiçoamento do código apresentado aqui.

Testado com IDE 1.8.1 e ESP8266 Core v2.3.0

Melhorias:

Não é preciso pré-codificar usuário e senha em base64. Eu inclui as rotinas para isso;
Removi o uso de flash strings, que aparentemente era a causa da rotina demorar absurdamente em certos pontos;
Usei constantes no lugar de strings “hardcoded”;

/*
 * Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas
 * Use uma conta de email descartável
 *
 *  
 */
// Você precisa mudar estas constantes ==========================
#include <ESP8266WiFi.h>
const char* SSID = "-------------";
const char* PASS = "-------------";
char smtp_server[] = "exemplo.com.br";
//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia
const int smtp_port = 587; //pode ser 25, 2525, 587, etc. Veja com seu provedor de email.
const String mail_username="user@exemplo.com.br";
const String mail_password="minhasenha";
const String mail_from="ESP8266 <user@servidor_remetente>";
const String mail_to="Jefferson <user@servidor_destino>";
const String mail_subject="Enviado pelo ESP8266";
const String mail_line1="Esta é a linha 1\n";
const String mail_line2="Esta é a linha 2";
const String mail_line3="Esta é a linha 3";
//============================================================

const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;

void a3_to_a4(unsigned char * a4, unsigned char * a3) {
  a4[0] = (a3[0] & 0xfc) >> 2;
  a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
  a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
  a4[3] = (a3[2] & 0x3f);
}

int base64_encode(char *output, const char *input, int inputLen) {
  int i = 0, j = 0;
  int encLen = 0;
  unsigned char a3[3];
  unsigned char a4[4];
  while(inputLen--) {
    a3[i++] = *(input++);
    if(i == 3) {
      a3_to_a4(a4, a3);
      for(i = 0; i < 4; i++) {
        output[encLen++] = _b64_alphabet[a4[i]];
      }
      i = 0;
    }
  }
  if(i) {
    for(j = i; j < 3; j++) {
      a3[j] = '\0';
    }
    a3_to_a4(a4, a3);
    for(j = 0; j < i + 1; j++) {
      output[encLen++] = _b64_alphabet[a4[j]];
    }
    while((i++ < 3)) {
      output[encLen++] = '=';
    }
  }
  output[encLen] = '\0';
  return encLen;
}

void setup()
{
  Serial.begin(115200);
  delay(10);
  Serial.println("");
  Serial.println("");
  Serial.print("Connecting To ");
  Serial.println(SSID);
  WiFi.begin(SSID, PASS);

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  byte ret = sendEmail();
}

void loop()
{
}

byte sendEmail()
{
  byte thisByte = 0;
  byte respCode;

  if (client.connect(smtp_server, smtp_port) == 1) {
    Serial.println("connected");
  } else {
    Serial.println("connection failed");
    return 0;
  }
  if (!eRcv()) return 0;

    char* buf = (char*)malloc(100);

  Serial.println("Sending EHLO");
  client.print("EHLO ");
  client.println(smtp_server); 
  if (!eRcv()) return 0;
  Serial.println("Sending auth login");
  client.println("auth login");
  if (!eRcv()) return 0;
  Serial.println("Sending User");
  base64_encode(buf, mail_username.c_str(), mail_username.length());
  client.println(buf);  
  if (!eRcv()) return 0;
  
  Serial.println("Sending Password");
  base64_encode(buf, mail_password.c_str(), mail_password.length());
  client.println(buf);   
  if (!eRcv()) return 0;
  
  Serial.println("Sending From");
  // change to your email address (sender)
  client.print("MAIL From: ");
  client.println(mail_from);
  if (!eRcv()) return 0;
  // change to recipient address
  Serial.println("Sending To");
  client.print("RCPT To: ");
  client.println(mail_to);
  if (!eRcv()) return 0;
  Serial.println("Sending DATA");
  client.println("DATA");
  if (!eRcv()) return 0;
  Serial.println("Sending email");
  // change to recipient address
  client.print("To: ");
  client.println(mail_to);
  // change to your address
  client.print("From: "); 
  client.println(mail_from); //Este é o "nome para exibição"
  client.print("Subject: ");
  client.print(mail_subject);
  client.println("\r\n");    
  client.println(mail_line1);
  client.println(mail_line2);
  client.println(mail_line3);
  client.println("."); //O email tem que terminar assim
  if (!eRcv()) return 0;
  Serial.println("Sending QUIT");
  client.println("QUIT");
  if (!eRcv()) return 0;
  client.stop();
  Serial.println("disconnected");
  return 1;
}

byte eRcv()
{
  byte respCode;
  byte thisByte;
  int loopCount = 0;

  while (!client.available()) {
    delay(1);
    loopCount++;
    // if nothing received for 10 seconds, timeout
    if (loopCount > 10000) {
      client.stop();
      Serial.println("\r\nTimeout");
      return 0;
    }
  }

  respCode = client.peek();
  while (client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);
  }

  if (respCode >= '4')
  {
    //  efail();
    return 0;
  }
  return 1;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

* Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas

* Use uma conta de email descartável

// Você precisa mudar estas constantes ==========================

#include <ESP8266WiFi.h>

const char* SSID = "-------------";

const char* PASS = "-------------";

char smtp_server[] = "exemplo.com.br";

//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia

const int smtp_port = 587; //pode ser 25, 2525, 587, etc. Veja com seu provedor de email.

const String mail_username="user@exemplo.com.br";

const String mail_password="minhasenha";

const String mail_from="ESP8266 <user@servidor_remetente>";

const String mail_to="Jefferson <user@servidor_destino>";

const String mail_subject="Enviado pelo ESP8266";

const String mail_line1="Esta é a linha 1\n";

const String mail_line2="Esta é a linha 2";

const String mail_line3="Esta é a linha 3";

//============================================================

const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;

void a3_to_a4(unsigned char * a4, unsigned char * a3) {

a4[0] = (a3[0] & 0xfc) >> 2;

a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);

a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);

a4[3] = (a3[2] & 0x3f);

}

int base64_encode(char *output, const char *input, int inputLen) {

int i = 0, j = 0;

int encLen = 0;

unsigned char a3[3];

unsigned char a4[4];

while(inputLen--) {

a3[i++] = *(input++);

if(i == 3) {

a3_to_a4(a4, a3);

for(i = 0; i < 4; i++) {

output[encLen++] = _b64_alphabet[a4[i]];

}

i = 0;

}

if(i) {

for(j = i; j < 3; j++) {

a3[j] = '\0';

}

a3_to_a4(a4, a3);

for(j = 0; j < i + 1; j++) {

output[encLen++] = _b64_alphabet[a4[j]];

}

while((i++ < 3)) {

output[encLen++] = '=';

}

output[encLen] = '\0';

return encLen;

}

void setup()

{

Serial.begin(115200);

delay(10);

Serial.println("");

Serial.print("Connecting To ");

Serial.println(SSID);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED)

{

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi Connected");

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

byte ret = sendEmail();

}

void loop()

{

}

byte sendEmail()

{

byte thisByte = 0;

byte respCode;

if (client.connect(smtp_server, smtp_port) == 1) {

Serial.println("connected");

} else {

Serial.println("connection failed");

return 0;

}

if (!eRcv()) return 0;

char* buf = (char*)malloc(100);

Serial.println("Sending EHLO");

client.print("EHLO ");

client.println(smtp_server);

if (!eRcv()) return 0;

Serial.println("Sending auth login");

client.println("auth login");

if (!eRcv()) return 0;

Serial.println("Sending User");

base64_encode(buf, mail_username.c_str(), mail_username.length());

client.println(buf);

if (!eRcv()) return 0;

Serial.println("Sending Password");

base64_encode(buf, mail_password.c_str(), mail_password.length());

client.println(buf);

if (!eRcv()) return 0;

Serial.println("Sending From");

// change to your email address (sender)

client.print("MAIL From: ");

client.println(mail_from);

if (!eRcv()) return 0;

// change to recipient address

Serial.println("Sending To");

client.print("RCPT To: ");

client.println(mail_to);

if (!eRcv()) return 0;

Serial.println("Sending DATA");

client.println("DATA");

if (!eRcv()) return 0;

Serial.println("Sending email");

// change to recipient address

client.print("To: ");

client.println(mail_to);

// change to your address

client.print("From: ");

client.println(mail_from); //Este é o "nome para exibição"

client.print("Subject: ");

client.print(mail_subject);

client.println("\r\n");

client.println(mail_line1);

client.println(mail_line2);

client.println(mail_line3);

client.println("."); //O email tem que terminar assim

if (!eRcv()) return 0;

Serial.println("Sending QUIT");

client.println("QUIT");

if (!eRcv()) return 0;

client.stop();

Serial.println("disconnected");

return 1;

}

byte eRcv()

{

byte respCode;

byte thisByte;

int loopCount = 0;

while (!client.available()) {

delay(1);

loopCount++;

// if nothing received for 10 seconds, timeout

if (loopCount > 10000) {

client.stop();

Serial.println("\r\nTimeout");

return 0;

}

respCode = client.peek();

while (client.available())

{

thisByte = client.read();

Serial.write(thisByte);

}

if (respCode >= '4')

{

// efail();

return 0;

}

return 1;

}

Versão que prefiro

Eu criei esta versão porque preferia uma rotina de envio mais “limpa” e o log na porta serial feito de forma a representar com mais fidelidade a comunicação com o servidor.

/*
 * Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas
 * Use uma conta de email descartável
 *
 *  
 */
#include <ESP8266WiFi.h>
const char* SSID = "";
const char* PASS = "";
char smtp_server[] = "";
//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia
const int smtp_port = 587; //pode ser 25, 2525 587, 465, etc. Veja com seu provedor de email.
const String mail_username="";
const String mail_password="";
const String mail_from="";
const String mail_to="";
const String mail_subject="Enviado pelo ESP8266";
const String mail_line1="Esta é a linha 1\n";
const String mail_line2="Esta é a linha 2";
const String mail_line3="Esta é a linha 3";


bool construindoLinha=false;
const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;

void printFreeRAM(){
  Serial.print("RAM livre: ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" bytes.");
}

void a3_to_a4(unsigned char * a4, unsigned char * a3) {
  a4[0] = (a3[0] & 0xfc) >> 2;
  a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
  a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
  a4[3] = (a3[2] & 0x3f);
}

int base64_encode(char *output, const char *input, int inputLen) {
  int i = 0, j = 0;
  int encLen = 0;
  unsigned char a3[3];
  unsigned char a4[4];
  while(inputLen--) {
    a3[i++] = *(input++);
    if(i == 3) {
      a3_to_a4(a4, a3);
      for(i = 0; i < 4; i++) {
        output[encLen++] = _b64_alphabet[a4[i]];
      }
      i = 0;
    }
  }
  if(i) {
    for(j = i; j < 3; j++) {
      a3[j] = '\0';
    }
    a3_to_a4(a4, a3);
    for(j = 0; j < i + 1; j++) {
      output[encLen++] = _b64_alphabet[a4[j]];
    }
    while((i++ < 3)) {
      output[encLen++] = '=';
    }
  }
  output[encLen] = '\0';
  return encLen;
}

void setup()
{
  Serial.begin(115200);
  delay(10);
  Serial.println("");
  Serial.println("");
  Serial.print("Conectando a: ");
  Serial.println(SSID);
  Serial.print("Com a senha: ");
  Serial.println(PASS);  
  WiFi.begin(SSID, PASS);

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Conectado.");
  Serial.print("Endereco IP local: ");
  Serial.println(WiFi.localIP());
  
  printFreeRAM();
  byte ret = sendEmail();
  printFreeRAM();
}

void loop()
{
}

void SEND(String message)
{
  if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
  Serial.print (message);
  client.print (message);
  construindoLinha=true;
  
}

void SENDln(String message)
{
  if (!construindoLinha){Serial.print("EU: ");};  //Imprimo apenas no início de cada linha
  Serial.println (message);
  client.println (message);
  construindoLinha=false;  
}

byte sendEmail()
{
  byte thisByte = 0;
  byte respCode;

  if (client.connect(smtp_server, smtp_port) == 1) {
    Serial.println("Conectado.");
  } else {
    Serial.println("Falha na conexao.");
    return 0;
  }
  if (!eRcv()) return 0;

  char* buf = (char*)malloc(100);

  SEND("EHLO ");
  SENDln(smtp_server); 
  if (!eRcv()) return 0;

  SENDln("auth login");
  if (!eRcv()) return 0;

  base64_encode(buf, mail_username.c_str(), mail_username.length());
  client.println(buf);  
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  base64_encode(buf, mail_password.c_str(), mail_password.length());
  client.println(buf);   
  Serial.println(buf);
  if (!eRcv()) return 0;
  
  SEND("MAIL From: ");
  SENDln(mail_from);
  if (!eRcv()) return 0;
  
  SEND("RCPT To: ");
  SENDln(mail_to);
  if (!eRcv()) return 0;
  
  SENDln("DATA");
  if (!eRcv()) return 0;
  
  SEND("To: ");
  SENDln(mail_to);
  SEND("From: "); 
  SENDln(mail_from); //Este é o "nome para exibição"
  SEND("Subject: ");
  SENDln(mail_subject);
  SENDln(mail_line1);
  SENDln(mail_line2);
  SENDln(mail_line3);
  SENDln("."); //O email tem que terminar assim
  if (!eRcv()) return 0;

  SENDln("QUIT");
 
  if (!eRcv()) return 0;
  client.stop();
  Serial.println("Desconectado.");
  return 1;
}

byte eRcv()
{
  byte respCode;
  byte thisByte;
  int loopCount = 0;

  while (!client.available()) {
    delay(1);
    loopCount++;
    // Se nada for recebido em 10s, desisto.
    if (loopCount > 10000) {
      client.stop();
      Serial.println("\r\nTimeout");
      return 0;
    }
  }

  respCode = client.peek();
  while (client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);
  }

  if (respCode >= '4')
  {
    //  efail();
    return 0;
  }
  return 1;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

* Este sketch não usa conexão criptografada. Suas credenciais poderão ser interceptadas

* Use uma conta de email descartável

#include <ESP8266WiFi.h>

const char* SSID = "";

const char* PASS = "";

char smtp_server[] = "";

//esta tem que ser a porta do seu provedor que aceita conexões sem criptografia

const int smtp_port = 587; //pode ser 25, 2525 587, 465, etc. Veja com seu provedor de email.

const String mail_username="";

const String mail_password="";

const String mail_from="";

const String mail_to="";

const String mail_subject="Enviado pelo ESP8266";

const String mail_line1="Esta é a linha 1\n";

const String mail_line2="Esta é a linha 2";

const String mail_line3="Esta é a linha 3";

bool construindoLinha=false;

const char* _b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

WiFiClient client;

void printFreeRAM(){

Serial.print("RAM livre: ");

Serial.print(ESP.getFreeHeap());

Serial.println(" bytes.");

}

void a3_to_a4(unsigned char * a4, unsigned char * a3) {

a4[0] = (a3[0] & 0xfc) >> 2;

a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);

a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);

a4[3] = (a3[2] & 0x3f);

}

int base64_encode(char *output, const char *input, int inputLen) {

int i = 0, j = 0;

int encLen = 0;

unsigned char a3[3];

unsigned char a4[4];

while(inputLen--) {

a3[i++] = *(input++);

if(i == 3) {

a3_to_a4(a4, a3);

for(i = 0; i < 4; i++) {

output[encLen++] = _b64_alphabet[a4[i]];

}

i = 0;

}

if(i) {

for(j = i; j < 3; j++) {

a3[j] = '\0';

}

a3_to_a4(a4, a3);

for(j = 0; j < i + 1; j++) {

output[encLen++] = _b64_alphabet[a4[j]];

}

while((i++ < 3)) {

output[encLen++] = '=';

}

output[encLen] = '\0';

return encLen;

}

void setup()

{

Serial.begin(115200);

delay(10);

Serial.println("");

Serial.print("Conectando a: ");

Serial.println(SSID);

Serial.print("Com a senha: ");

Serial.println(PASS);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED)

{

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi Conectado.");

Serial.print("Endereco IP local: ");

Serial.println(WiFi.localIP());

printFreeRAM();

byte ret = sendEmail();

printFreeRAM();

}

void loop()

{

}

void SEND(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.print (message);

client.print (message);

construindoLinha=true;

}

void SENDln(String message)

{

if (!construindoLinha){Serial.print("EU: ");}; //Imprimo apenas no início de cada linha

Serial.println (message);

client.println (message);

construindoLinha=false;

}

byte sendEmail()

{

byte thisByte = 0;

byte respCode;

if (client.connect(smtp_server, smtp_port) == 1) {

Serial.println("Conectado.");

} else {

Serial.println("Falha na conexao.");

return 0;

}

if (!eRcv()) return 0;

char* buf = (char*)malloc(100);

SEND("EHLO ");

SENDln(smtp_server);

if (!eRcv()) return 0;

SENDln("auth login");

if (!eRcv()) return 0;

base64_encode(buf, mail_username.c_str(), mail_username.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

base64_encode(buf, mail_password.c_str(), mail_password.length());

client.println(buf);

Serial.println(buf);

if (!eRcv()) return 0;

SEND("MAIL From: ");

SENDln(mail_from);

if (!eRcv()) return 0;

SEND("RCPT To: ");

SENDln(mail_to);

if (!eRcv()) return 0;

SENDln("DATA");

if (!eRcv()) return 0;

SEND("To: ");

SENDln(mail_to);

SEND("From: ");

SENDln(mail_from); //Este é o "nome para exibição"

SEND("Subject: ");

SENDln(mail_subject);

SENDln(mail_line1);

SENDln(mail_line2);

SENDln(mail_line3);

SENDln("."); //O email tem que terminar assim

if (!eRcv()) return 0;

SENDln("QUIT");

if (!eRcv()) return 0;

client.stop();

Serial.println("Desconectado.");

return 1;

}

byte eRcv()

{

byte respCode;

byte thisByte;

int loopCount = 0;

while (!client.available()) {

delay(1);

loopCount++;

// Se nada for recebido em 10s, desisto.

if (loopCount > 10000) {

client.stop();

Serial.println("\r\nTimeout");

return 0;

}

respCode = client.peek();

while (client.available())

{

thisByte = client.read();

Serial.write(thisByte);

}

if (respCode >= '4')

{

// efail();

return 0;

}

return 1;

}

Postado em Informação | 4 Comments

ESP8266: Como fazer um atualizador para DDNS Cloudflare

Posted on 7 de julho de 2017 by Jefferson

Eu não sou programador. Tudo o que garanto é que nas condições certas o programa funciona.

Correções e aperfeiçoamentos são bem-vindos.

Você precisa de:

Um ESP8266 qualquer – Testado com o ESP-01 de 512KB
IDE Arduino – Testado com a versão 1.8.1
“Board” ESP82666 Core – Testado com a versão 2.3.0
Biblioteca ArduinoJSON

Preencha os dados da sua rede sem fio e da sua conta Cloudflare e faça o upload. Se tudo estiver certo o procedimento do programa será o seguinte:

Ao inicializar:

Verifica o IP registrado para o host na sua conta Cloudflare;
Verifica com checkip.dyndns.org qual o seu IP externo atual;
Se forem diferentes atualiza a sua conta Cloudflare;
Guarda o IP para não precisar mais consultar a conta;

A cada 10 minutos

Verifica com checkip.dyndns.org qual o seu IP externo atual;
Compara com o ip armazenado e atualiza sua conta se forem diferentes;

Em caso de erro o programa reduz o intervalo entre checagens para 2 minutos. Retorna a 10 minutos após o primeiro sucesso.

A melhorar:

As rotinas de parse ainda são uma gambiarra;
Não testei se minhas checagens de erro realmente funcionam;
Com mais alguns GETs e parses JSON é possível obter o zone_id e o host_id a partir do host_name. Isso simplifica a vida de quem não sabe obter essas informações.

/*
 * Cloudflare DDNS Updater for ESP8266
 * Jefferson Ryan - automalabs.com.br 
 * Testado com IDE v1.8.1 e ESP8266 Core v2.3.0
 */

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>
#include <Ticker.h>

Ticker tick;

// Você precisa preencher estes valores ========================================================
//sua rede sem fio
const char* ssid = "";
const char* password = "";

//cloudflare
const String zone_id = "";
const String host_id = ""; 
const String host_name = "";
const String login_email = "";
const String api_key = "";  
//================================================================================================



const char* cloudflare_host = "api.cloudflare.com";
//const String user_agent="Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0";
const String user_agent="ESP8266_DDNS_Updater";  //A Cloudflare exige um user_agent. É educado não mentir se não for indispensável. 
const int httpsPort = 443;

char ipservice[] = "checkip.dyndns.com";

//Obtido através de debug. É diferente do exibido pelo browser
//Precisará ser atualizado manualmente quando o certificado expirar
const char* cloudflare_host_fingerprint = "6F 1F FB 38 B9 49 03 1E 84 AF DC 48 C8 81 84 45 1A 19 6F 70";


  WiFiClientSecure secureClient;
  WiFiClient UnsecureClient;
  DynamicJsonBuffer jsonBuffer;

  String ipExterno;
  String ipRegistrado;
  String ipAnterior;
  boolean refresh=false;
  const int maxIntervaloChecagens=10;
  const int minIntervaloChecagens=2;
  int minutos=0;
  int intervaloChecagens=maxIntervaloChecagens;

void oneMinute() {

  //oneMinute é uma callback. Executar algo complexo ("blocking") pode levar a resets do ESP8266
  minutos++;
  if (intervaloChecagens-minutos<1){ 
    minutos=0;
    refresh=true;
  }
  else{

    int MinutosRestantes=intervaloChecagens-minutos;
    Serial.print(MinutosRestantes);
    Serial.println(" minutos para proxima checagem");
    
  }

  
}  

boolean GETMyIP(){
  boolean result=true;
  Serial.print("Conectando a ");
  Serial.println(ipservice);
  if (!UnsecureClient.connect(ipservice, 80)) {
    Serial.println("Falha na conexao.");
    result=false;
    return result;
  }

 
  String url = "/";
  UnsecureClient.print("GET " + url + " HTTP/1.1\n");
  UnsecureClient.print("Host: " + (String)ipservice+"\n");
  UnsecureClient.print("Connection: close\n");
  UnsecureClient.print("User-Agent: "+user_agent+"\n");
  UnsecureClient.print("\r\n\r\n");

  Serial.print("Esperando resposta.");

 int limiteEspera=500;
 int count=0;
 //TODO: Seria melhor usar um FOR aqui?
 while (UnsecureClient.available() < 1) {  //espero por uma resposta
    count++;
    Serial.print(".");
    delay(100);
    if (count>limiteEspera){
      Serial.println("Desisti de esperar.");
      Serial.println("Fechando Conexao.");
      UnsecureClient.stop(); 
      return false;     
      break;
    }
  } 
  
  Serial.println(""); //Separo dos "."

  String line;  
  while(UnsecureClient.available()) //processo a resposta
  {
    line = UnsecureClient.readStringUntil('\n');
    // Serial.println(line);
    if (line.substring(0,5)=="<html"){
      ipExterno= line.substring(line.indexOf(":")+2);
      ipExterno= ipExterno.substring(0,ipExterno.indexOf("<"));
      Serial.print("ipExterno: ");
      Serial.println(ipExterno);
    }
  }
  Serial.println("");
  Serial.println("Fechando conexao.");
  UnsecureClient.stop();
  return result; 
}



boolean conectarCloudflare(){
  Serial.print("Conectando a ");
  Serial.println(cloudflare_host);
  if (!secureClient.connect(cloudflare_host, httpsPort)) {
    Serial.println("A conexao falhou");
    return false;
  }

  if (secureClient.verify(cloudflare_host_fingerprint, cloudflare_host)) {
    Serial.println("O certificado confere.");
    return true;    
  } else {
    Serial.println("O certificado nao confere. Cancelando.");
    secureClient.stop();
    return false;
  }
}  



boolean SEND(String action){
  boolean result=false;
  if (!conectarCloudflare()){return result;};
  
  String url = "/client/v4/zones/"+zone_id+"/dns_records/"+host_id;
  Serial.print("Acessando URL: ");
  Serial.println(url);
  secureClient.print(action +" " + url + " HTTP/1.1\n");
  secureClient.print("Host: " + (String)cloudflare_host+":443\n");  //TODO: colocar a porta em uma constante
  secureClient.print("Connection: close\n");
  secureClient.print("User-Agent: "+user_agent+"\n");
  secureClient.print("X-Auth-Email: "+login_email+"\n");
  secureClient.print("Content-Type: application/json\n");  
  secureClient.print("X-Auth-Key: "+api_key+"\n");  

  if (action=="PUT"){
      //String original: {"type":"A","name":"r7.automalabs.com.br","content":"127.0.0.1","ttl":120,"proxied":false}
      String postData = "{\"type\":\"A\",\"name\":\""+host_name+"\",\"content\":\""+ipExterno+"\",\"ttl\":120,\"proxied\":false}";   
      secureClient.print("Content-Length: ");
      secureClient.print(postData.length());
      secureClient.print("\r\n\r\n");
      secureClient.print(postData);
  }
  else
  {
      secureClient.print("\r\n\r\n");
  }
  Serial.print(action);
  Serial.print(" enviado. ");

  Serial.print("Esperando resposta.");

 int limiteEspera=500;
 int count=0;
 //TODO: Seria melhor usar um FOR aqui?
 while (secureClient.available() < 1) {  //espero por uma resposta
    count++;
    Serial.print(".");
    delay(100);
    if (count>limiteEspera){
      Serial.println("Desisti de esperar.");
      Serial.println("Fechando Conexao.");
      secureClient.stop(); 
      return false;     
      break;
    }
  } 
  
  Serial.println(""); //Separo dos "."

  String line;  
  while(secureClient.available()) //processo a resposta
  {
    line = secureClient.readStringUntil('\n');
    if (line.substring(2,8)=="result"){
      Serial.println(line);
      String ip= ParseJSON(line.substring(10));  //TODO: fazer processar toda a string
      if (ip!=""){ 
       ipRegistrado=ip;
       result=true;
      }
      else{
       result=false;
        
      }
      
    }
   // Serial.println(line); //Util apenas para debug;

  }
  Serial.println("");
  Serial.println("Fechando conexao.");
  Serial.println("");
  secureClient.stop(); 
  return result;
}


String ParseJSON(String json){

  JsonObject& root = jsonBuffer.parseObject(json);

  if (!root.success()) {
    Serial.println("parseObject() falhou");
    return "";
  }

  //TODO: fazer o parse de "success" também
  String nome = root["name"];
  String ip = root["content"];
  
  
  Serial.println(nome);
  Serial.println(ip);
  return ip;
}

void setup() {
  tick.attach(60, oneMinute); //Executa oneMinute a cada 60 segundos
  Serial.begin(115200);
  //Serial.setDebugOutput(true);
  Serial.println();
  Serial.print("Conectando ao AP: ");
  Serial.println(ssid);
  Serial.print("Com a senha: ");
  Serial.println(password);  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi conectado.");
  Serial.print("Endereco IP do ESP8266: ");
  Serial.println(WiFi.localIP());

  if (SEND("GET")){
  compararEatualizar(ipRegistrado);
  }

}


void loop() {

  if (refresh) {
  refresh=false;  
  compararEatualizar(ipAnterior);
  }
  
}

void compararEatualizar(String ip) {

  if (GETMyIP()){ 
  if (ipExterno==ip){
    Serial.println("Os IPs sao iguais.");
    intervaloChecagens=maxIntervaloChecagens; 
  }
    else
    {   Serial.print("IP: ");
        Serial.println(ip);
        Serial.print("IP externo: ");
        Serial.println(ipExterno);  
        Serial.println("Os IPs sao diferentes. Iniciando arualizacao.");        
    if (SEND("PUT")){
      if (ipExterno!=ipRegistrado){
        Serial.println("Erro ao atualizar o IP.");
        Serial.print("IP na cloudflare: ");
        Serial.println(ipRegistrado);
        Serial.print("IP externo: ");
        Serial.println(ipExterno);
        intervaloChecagens=minIntervaloChecagens; //PUT falhou
      }
      else{
         ipAnterior=ipExterno;
         intervaloChecagens=maxIntervaloChecagens; 
      }
    }
  } 
   }
   else
   {
   intervaloChecagens=minIntervaloChecagens;  //GetMyIP falhou
   }
  Serial.print(intervaloChecagens);
  Serial.println(" minutos para proxima checagem");
  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

* Cloudflare DDNS Updater for ESP8266

* Jefferson Ryan - automalabs.com.br

* Testado com IDE v1.8.1 e ESP8266 Core v2.3.0

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

#include <ArduinoJson.h>

#include <Ticker.h>

Ticker tick;

// Você precisa preencher estes valores ========================================================

//sua rede sem fio

const char* ssid = "";

const char* password = "";

//cloudflare

const String zone_id = "";

const String host_id = "";

const String host_name = "";

const String login_email = "";

const String api_key = "";

//================================================================================================

const char* cloudflare_host = "api.cloudflare.com";

//const String user_agent="Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0";

const String user_agent="ESP8266_DDNS_Updater"; //A Cloudflare exige um user_agent. É educado não mentir se não for indispensável.

const int httpsPort = 443;

char ipservice[] = "checkip.dyndns.com";

//Obtido através de debug. É diferente do exibido pelo browser

//Precisará ser atualizado manualmente quando o certificado expirar

const char* cloudflare_host_fingerprint = "6F 1F FB 38 B9 49 03 1E 84 AF DC 48 C8 81 84 45 1A 19 6F 70";

WiFiClientSecure secureClient;

WiFiClient UnsecureClient;

DynamicJsonBuffer jsonBuffer;

String ipExterno;

String ipRegistrado;

String ipAnterior;

boolean refresh=false;

const int maxIntervaloChecagens=10;

const int minIntervaloChecagens=2;

int minutos=0;

int intervaloChecagens=maxIntervaloChecagens;

void oneMinute() {

//oneMinute é uma callback. Executar algo complexo ("blocking") pode levar a resets do ESP8266

minutos++;

if (intervaloChecagens-minutos<1){

minutos=0;

refresh=true;

}

else{

int MinutosRestantes=intervaloChecagens-minutos;

Serial.print(MinutosRestantes);

Serial.println(" minutos para proxima checagem");

}

boolean GETMyIP(){

boolean result=true;

Serial.print("Conectando a ");

Serial.println(ipservice);

if (!UnsecureClient.connect(ipservice, 80)) {

Serial.println("Falha na conexao.");

result=false;

return result;

}

String url = "/";

UnsecureClient.print("GET " + url + " HTTP/1.1\n");

UnsecureClient.print("Host: " + (String)ipservice+"\n");

UnsecureClient.print("Connection: close\n");

UnsecureClient.print("User-Agent: "+user_agent+"\n");

UnsecureClient.print("\r\n\r\n");

Serial.print("Esperando resposta.");

int limiteEspera=500;

int count=0;

//TODO: Seria melhor usar um FOR aqui?

while (UnsecureClient.available() < 1) { //espero por uma resposta

count++;

Serial.print(".");

delay(100);

if (count>limiteEspera){

Serial.println("Desisti de esperar.");

Serial.println("Fechando Conexao.");

UnsecureClient.stop();

return false;

break;

}

Serial.println(""); //Separo dos "."

String line;

while(UnsecureClient.available()) //processo a resposta

{

line = UnsecureClient.readStringUntil('\n');

// Serial.println(line);

if (line.substring(0,5)=="<html"){

ipExterno= line.substring(line.indexOf(":")+2);

ipExterno= ipExterno.substring(0,ipExterno.indexOf("<"));

Serial.print("ipExterno: ");

Serial.println(ipExterno);

}

Serial.println("");

Serial.println("Fechando conexao.");

UnsecureClient.stop();

return result;

}

boolean conectarCloudflare(){

Serial.print("Conectando a ");

Serial.println(cloudflare_host);

if (!secureClient.connect(cloudflare_host, httpsPort)) {

Serial.println("A conexao falhou");

return false;

}

if (secureClient.verify(cloudflare_host_fingerprint, cloudflare_host)) {

Serial.println("O certificado confere.");

return true;

} else {

Serial.println("O certificado nao confere. Cancelando.");

secureClient.stop();

return false;

}

boolean SEND(String action){

boolean result=false;

if (!conectarCloudflare()){return result;};

String url = "/client/v4/zones/"+zone_id+"/dns_records/"+host_id;

Serial.print("Acessando URL: ");

Serial.println(url);

secureClient.print(action +" " + url + " HTTP/1.1\n");

secureClient.print("Host: " + (String)cloudflare_host+":443\n"); //TODO: colocar a porta em uma constante

secureClient.print("Connection: close\n");

secureClient.print("User-Agent: "+user_agent+"\n");

secureClient.print("X-Auth-Email: "+login_email+"\n");

secureClient.print("Content-Type: application/json\n");

secureClient.print("X-Auth-Key: "+api_key+"\n");

if (action=="PUT"){

//String original: {"type":"A","name":"r7.automalabs.com.br","content":"127.0.0.1","ttl":120,"proxied":false}

String postData = "{\"type\":\"A\",\"name\":\""+host_name+"\",\"content\":\""+ipExterno+"\",\"ttl\":120,\"proxied\":false}";

secureClient.print("Content-Length: ");

secureClient.print(postData.length());

secureClient.print("\r\n\r\n");

secureClient.print(postData);

}

else

{

secureClient.print("\r\n\r\n");

}

Serial.print(action);

Serial.print(" enviado. ");

Serial.print("Esperando resposta.");

int limiteEspera=500;

int count=0;

//TODO: Seria melhor usar um FOR aqui?

while (secureClient.available() < 1) { //espero por uma resposta

count++;

Serial.print(".");

delay(100);

if (count>limiteEspera){

Serial.println("Desisti de esperar.");

Serial.println("Fechando Conexao.");

secureClient.stop();

return false;

break;

}

Serial.println(""); //Separo dos "."

String line;

while(secureClient.available()) //processo a resposta

{

line = secureClient.readStringUntil('\n');

if (line.substring(2,8)=="result"){

Serial.println(line);

String ip= ParseJSON(line.substring(10)); //TODO: fazer processar toda a string

if (ip!=""){

ipRegistrado=ip;

result=true;

}

else{

result=false;

}

// Serial.println(line); //Util apenas para debug;

}

Serial.println("");

Serial.println("Fechando conexao.");

Serial.println("");

secureClient.stop();

return result;

}

String ParseJSON(String json){

JsonObject& root = jsonBuffer.parseObject(json);

if (!root.success()) {

Serial.println("parseObject() falhou");

return "";

}

//TODO: fazer o parse de "success" também

String nome = root["name"];

String ip = root["content"];

Serial.println(nome);

Serial.println(ip);

return ip;

}

void setup() {

tick.attach(60, oneMinute); //Executa oneMinute a cada 60 segundos

Serial.begin(115200);

//Serial.setDebugOutput(true);

Serial.println();

Serial.print("Conectando ao AP: ");

Serial.println(ssid);

Serial.print("Com a senha: ");

Serial.println(password);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi conectado.");

Serial.print("Endereco IP do ESP8266: ");

Serial.println(WiFi.localIP());

if (SEND("GET")){

compararEatualizar(ipRegistrado);

}

void loop() {

if (refresh) {

refresh=false;

compararEatualizar(ipAnterior);

}

void compararEatualizar(String ip) {

if (GETMyIP()){

if (ipExterno==ip){

Serial.println("Os IPs sao iguais.");

intervaloChecagens=maxIntervaloChecagens;

}

else

{ Serial.print("IP: ");

Serial.println(ip);

Serial.print("IP externo: ");

Serial.println(ipExterno);

Serial.println("Os IPs sao diferentes. Iniciando arualizacao.");

if (SEND("PUT")){

if (ipExterno!=ipRegistrado){

Serial.println("Erro ao atualizar o IP.");

Serial.print("IP na cloudflare: ");

Serial.println(ipRegistrado);

Serial.print("IP externo: ");

Serial.println(ipExterno);

intervaloChecagens=minIntervaloChecagens; //PUT falhou

}

else{

ipAnterior=ipExterno;

intervaloChecagens=maxIntervaloChecagens;

}

else

{

intervaloChecagens=minIntervaloChecagens; //GetMyIP falhou

}

Serial.print(intervaloChecagens);

Serial.println(" minutos para proxima checagem");

}

O programa não prossegue se o fingerprint do certificado for diferente do esperado. Infelizmente isso significa que quando o certificado da Clouflare for atualizado o programa deixará de funcionar até que um novo fingerprint seja inserido. Você pode remover esse requerimento mas fica sujeito a roubo de suas credenciais num ataque MITM. Uma sugestão seria armazenar o fingerprint em um arquivo no SPIFFS e fazer o programa ao não conseguir mais validar o certificado mandar uma mensagem para você e passar a procurar por uma atualização de fingerprint no seu domínio, em arquivo criptografado por você.

Infelizmente não parece haver meio do ESP8266 verificar a validade de certificados em tempo real. A checagem de fingerprints foi o melhor que a impressionante equipe por trás do desenvolvimento conseguiu fazer.

Ferramentas online úteis ao debugar esse projeto:

Teste da ArduinoJSON – Você pode testar algumas idéias sem ter que fazer upload para um arduino
dostring.com – Não sabe qual o tamanho do JSON em bytes? String Length diz.
JSON Parser Online – Não consegue visualizar a árvore mentalmente? Permite colapsar estruturas;

Postado em Informação | Tags: ESP8266 | 6 Comments

Como usar I2C no ESP8266 e especificamente no ESP-01

Posted on 3 de julho de 2017 by Jefferson

esp8266_esp01_automalabs Usando a IDE Arduino com Board ESP8266 é realmente muito simples. Não é preciso usar uma biblioteca I2C específica como é o caso de rede e seus programas já existentes devem funcionar exceto por um detalhe: você precisa especificar na inicialização da biblioteca Wire os pinos que você está usando para I2C no ESP8266.

Wire.begin(SDApin, SCLpin);

No ESP-01 você provavelmente vai ter que usar GPIO0 e GPIO2, por isso a inicialização fica assim:

Wire.begin(0, 2);

Em todos os casos você deve colocar resistores de pull-up de 4k7 nos GPIO que você escolheu para I2C. Atente para o fato de que alguns módulos i2C já vem com esses resistores.

No desenho SDA e SCL estão invertidos. Depois eu corrijo isso.

ESP-01_PCF8574_I2C

Postado em Informação | Tags: ESP8266, i2c | 1 Comment

Use o browser para debugar seu projeto que usa HTTP

Posted on 30 de junho de 2017 by Jefferson

Na maioria das vezes você não precisa instalar um proxy ou nada mais complicado para ver como está se comportando seu projeto. No Chrome, por exemplo, tecle F12 para abrir as ferramentas de desenvolvedor e clique na aba “network” (rede). Daí “visite” o seu projeto.
A cada clique que você der o Chrome vai mostrar que arquivos (CSS, imagens, javascript, etc) foram requisitados, que tamanho tinham, quanto tempo levou, quais não chegaram, a ordem das operações, etc.

Postado em Informação | Deixe um comentário

Category Archives: Informação

ESP8266: Como enviar email pelo GMAIL.

ESP8266: Como enviar e-mail por uma conexão criptografada (SSL/TLS).

ESP8266: Os LEDs do módulo ESP-01

ESP8266: GPIO no módulo ESP-01

ESP8266: Como enviar notificações usando o serviço Pushbullet

ESP8266: Como enviar um e-mail a cada x minutos em caso de alarme.

ESP8266: Como enviar e-mail por um servidor SMTP

ESP8266: Como fazer um atualizador para DDNS Cloudflare

Como usar I2C no ESP8266 e especificamente no ESP-01

Use o browser para debugar seu projeto que usa HTTP

Categorias

Busca por palavras

Busca por tags

Comentários

Meta