Menu

PDA IIoT - Teste do display OLED

Exibir informações na própria placa pode ajudar no desenvolvimento, assim um display OLED, 0.96 polegadas, foi conectado aos terminais I2C e sua principal finalidade é exibir status de conexão com a internet.
Importante para programação.

Endereço utilizado = 0x3c

GND = 0V 
VCC =3,3V
GPIO SCL = 22
GPIO SDA = 21

Mais no datasheet do Display...

O Programa


//******************************************************
// Projeto IIoT - Desenvolvimento com ESP32/IDE Arduino
// Testes da Placa PDAIIoT V1
// Programa/hardware: 003 - Teste do OLED / I2C 
// Referência:https://mjrobot.org/tag/oled/ 
// Autor:Clodoaldo Silva
// Revisão: 01mai2019

#include "SSD1306.h"      //Biblioteca do OLED
#include "Wire.h"         //Comunicação I2C

const int I2C_DISPLAY_ADDRESS = 0x3c; //endereço I2C
const int SDA_PIN = 21; //Pinos I2C ESp32 /PDA IIoT
const int SCL_PIN = 22;

SSD1306Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

void setup () 
{
  Serial.begin(115200); 
  displaySetup();
}
void loop() 
{ 
}
/* Initiate and display setup data on OLED */
void displaySetup()
{
  display.init();                   // initializa display
  display.clear();                  // Limpa display
  display.flipScreenVertically();   // Vira a tela do display
  display.display();                // Insere dados
  
  Serial.println("Inicializando...");
  
  display.setFont(ArialMT_Plain_24);
  display.drawString(30, 0, "PDA IIoT V1");  // (xpos, ypos, "Text")
  display.setFont(ArialMT_Plain_16);
  display.drawString(18, 29, "Teste OLED");
  display.setFont(ArialMT_Plain_10);
  display.drawString(10, 52, "Serial BaudRate:");
  display.drawString(90, 52, String(11500));
  display.display();  // Coloca dados no display
  delay (3000);
}





PDAIIoT - Teste de I/Os

Testando as entradas

Agora, nós iremos testar as entradas da placa utilizando os botões..

Uma vez que este projeto tem o objetivo de desenvolver projetos para IoT, foi colocado seis push buttons para simulação, assim podemos testá-las antes de aplica-la. As entradas foram conectadas aos seguintes GPIO. 

Push button SW01 = GPIO 25
Push button SW02 = GPIO 26
Push button SW03 = GPIO 27
Push button SW04 = GPIO 14
Push button SW05 = GPIO 12 - Deve ser pressionada para habilitar as saídas
Push button SW06 = GPIO 13

O programa de testes..

//***********************************************************************************
// Projeto IIoT - Desenvolvimento com ESP32/IDE Arduino
// Testes da Placa PDAIIoT V1
// Programa/hardware: 002 - Teste de entradas da PDA IIoT
// Autor:Clodoaldo Silva
// Revisão: 01mai2019

//DEFINE ENTRADAS E SAÍDAS DA PLACA DE DESENVOLVIMENTO
#define RELE_01 15  //define a saída GPIO 15 como Rele_01
#define RELE_02 2  //define a saída GPIO 15 como Rele_01
#define RELE_03 4  //define a saída GPIO 15 como Rele_01
#define RELE_04 16  //define a saída GPIO 15 como Rele_01
#define RELE_05 17  //define a saída GPIO 15 como Rele_01
#define RELE_06 5  //define a saída GPIO 15 como Rele_01
#define RELE_07 18  //define a saída GPIO 15 como Rele_01
#define RELE_08 19  //define a saída GPIO 15 como Rele_01

#define SW1 25      //define o pino GPIO 25 como botão
#define SW2 26      //define o pino GPIO 26 como botão
#define SW3 27      //define o pino GPIO 27 como botão
#define SW4 14      //define o pino GPIO 14 como botão
#define SW5 12      //define o pino GPIO 12 como botão
#define SW6 13      //define o pino GPIO 13 como botão

void setup() //Responsável pela configuração inicial do hardware.
{
  //Coloca os pinos como entrada ou saída.
  pinMode(RELE_01, OUTPUT);  // Pino será saída
  pinMode(RELE_02, OUTPUT);  // Pino será saída
  pinMode(RELE_03, OUTPUT);  // Pino será saída
  pinMode(RELE_04, OUTPUT);  // Pino será saída
  pinMode(RELE_05, OUTPUT);  // Pino será saída
  pinMode(RELE_06, OUTPUT);  // Pino será saída
  pinMode(RELE_07, OUTPUT);  // Pino será saída
  pinMode(RELE_08, OUTPUT);  // Pino será saída

  pinMode(SW1, INPUT);       // Pino será entrada com pullup interno habilitado
  pinMode(SW2, INPUT);       // Pino será entrada com pullup interno habilitado
}
void loop() //Função principal, responsável por rodar o programa repetidamente.
{
  if (digitalRead(SW1) == LOW)      // Se a chave estiver pressionada o pino receberá 0.
  {
    digitalWrite(RELE_01, HIGH);  // RELE_01 em nível alto
    digitalWrite(RELE_03, HIGH);  // RELE_03 em nível alto
    digitalWrite(RELE_05, HIGH);  // RELE_05 em nível alto
    digitalWrite(RELE_07, HIGH);  // RELE_07 em nível alto
  }
  else
  {
    digitalWrite(RELE_01, LOW);  // RELE_01 em nível baixo
    digitalWrite(RELE_03, LOW);  // RELE_03 em nível baixo
    digitalWrite(RELE_05, LOW);  // RELE_05 em nível baixo
    digitalWrite(RELE_07, LOW);  // RELE_07 em nível baixo
  }

  if (digitalRead(SW2) == LOW)      // Se a chave estiver pressionada o pino receberá 0.//  else // Senão
  {
    digitalWrite(RELE_02, HIGH);  // RELE_01 em nível alto
    digitalWrite(RELE_04, HIGH);  // RELE_03 em nível alto
    digitalWrite(RELE_06, HIGH);  // RELE_05 em nível alto
    digitalWrite(RELE_08, HIGH);  // RELE_07 em nível alto
  }
  else
  {
    digitalWrite(RELE_02, LOW);  // RELE_01 em nível baixo
    digitalWrite(RELE_04, LOW);  // RELE_03 em nível baixo
    digitalWrite(RELE_06, LOW);  // RELE_05 em nível baixo
    digitalWrite(RELE_08, LOW);  // RELE_07 em nível baixo
  }
}


Vejamos o teste usando somente SW1 e SW2




Observações:

O GPIO 12 que dá o start na saída funciona normalmente com entrada.

Placa de Desenvolvimento a aplicação para IIoT

O projeto PDA IIoT

A tempos tento desenvolver um hardware para desenvolvimento e aplicações em IIoT, recentemente terminei um protótipo que chamei de PDA IIoT V1 (Placa para desenvolvimento e Aplicação) para IoT industrial. 

A placa consiste em:

8 relés conectados aos seguintes GPIOs:

Relé 01 = GPIO 15
Relé 02 = GPIO 02
Relé 03 = GPIO 04
Relé 04 = GPIO 16
Relé 05 = GPIO 17
Relé 06 = GPIO 05
Relé 07 = GPIO 18
Relé 08 = GPIO 19

A ideia é usar a IDE do Auduino para fins de testes ...

Testando as saídas

//***********************************************************************************
// Projeto IIoT - Desenvolvimento com ESP32/IDE Arduino
// Testes da Placa PDAIIoT V1
// Programa/hardware: 001 - Pisca LED/Relé
// Autor:Clodoaldo Silva
// Revisão: 01mai2019

//DEFINE ENTRADAS E SAÍDAS DA PLACA DE DESENVOLVIMENTO
#define LED_01 15 //define a saída GPIO 15
#define LED_02 2 //define a saída GPIO 12
#define LED_03 4 //define a saída GPIO 4
#define LED_04 16 //define a saída GPIO 16
#define LED_05 17 //define a saída GPIO 17
#define LED_06 5 //define a saída GPIO 5
#define LED_07 18 //define a saída GPIO 18
#define LED_08 19 //define a saída GPIO 19

void setup() //Responsável pela configuração inicial do hardware.
{
  //Coloca os pinos como entrada ou saída.
  pinMode(LED_01, OUTPUT);            // Pino será saída
  pinMode(LED_02, OUTPUT);            // Pino será saída
  pinMode(LED_03, OUTPUT);            // Pino será saída
  pinMode(LED_04, OUTPUT);            // Pino será saída
  pinMode(LED_05, OUTPUT);            // Pino será saída
  pinMode(LED_06, OUTPUT);            // Pino será saída
  pinMode(LED_07, OUTPUT);            // Pino será saída
  pinMode(LED_08, OUTPUT);            // Pino será saída
}
void loop() //Função principal, responsável por rodar o programa repetidamente.
{
  {
    digitalWrite(LED_01, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_01, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_02, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_02, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_03, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_03, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_04, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_04, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_05, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_05, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_06, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_06, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_07, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_07, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);

    digitalWrite(LED_08, HIGH);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
    digitalWrite(LED_08, LOW);       // O pino GPIO15 (LED_01) em nível alto
    delay(500);
  }
}


Vejamos os testes..


Observações observadas...

  • Se o GPIO 12 estiver desconectado o ESP32 DEVKIT V1 funciona normalmente..
  • Como liguei o GPIO 12 a uma entrada as saídas só após pressionar o mesmo, funciona como um start. 


Aulas 000 - Microcontroladores PIC e XC8

Hardware básico

Para iniciarmos nossas aulas necessitamos de um hardware básico que será construido no software proteus.

Alimentação
Embora não esteja no esquema os microcontroladores trabalham com 5VDC.

Reset
Este modelo de PIC possui um MCLEAR (pino 1) que deve ser mantido em (1) para que ele funcione e se for colocado em (0) ele reseta o PIC.

Usamos um push button e um resistor de 10K para mantermos o pino sempre em (1) alto e quando pressionarmos a o button ele vai para (0).

Oscilador
Embora o PIC tenha um oscilador interno ele não é confiável e haverá situações em práticas que a confiabilidade do clock é de suma importância e para tal um oscilador externo com os capacitores de filtro são necessários.

A Microchip responsável pelos microcontroladores da família PIC, subdivide os cristais em três grupos
  • LP :- Cristais de baixa potência - para cristais entre 32 kHz e 220 kHz;
  • XT :- Cristais - para cristais entre 220 kHz e 4 MHz;
  • HS :- Cristais de alta velocidade - para cristais entre 4 MHz e 20 MHz.
Usaremos o cristal HS cujo fabricante recomenta capacitores de 15 a 33 pF.

Dispositivos de Entrada/Saída (I/O)

Um microcontrolador sozinho não tem utilidade, para que ele seja útil ele necessita receber sinais e assim processá-las e acionar uma saída que atenda a necessidade do projeto.

Para entrada colocaremos 4 botões (push button) com resistores pull-down.


Importante:

Pull-UP = Resistor de pull-up, o pino de entrada irá ler um estado em nível alto quando o botão não está sendo pressionado. (usamos no pino de reset)

Pull-Down = Resistor de pull-down, o pino de entrada irá ler um estado em nível baixo quando o botão não está sendo pressionado. (usamos nos pinos de entrada)

Para saída colocaremos 4 LEDs, obviamente com resistores limitadores, uma vez que o LED opera com 2V (corrente de 10 a 50mA) e a saída do microcontrolador é 5V.



Lembrando:

R = (Vmicro - VLED)/ILED
R = (5V - 2V)/20mA
R = 150 ohm















A IDE MPLAB X e o Compilador XC8

Para programarmos o microcontrolador, precisamos de uma IDE, ou seja, uma interface de desenvolvimento que neste caso será o MPLABX.

MPLAB - Software editor para gerenciamento de projetos e ambiente de programação para desenvolvimento de aplicações e sistemas embarcados.

A linguagem de programação C é uma linguagem de alto nível, fácil de ser entendida por nós, más a linguagem que descarregamos nos microcontroladores é de baixo nível, assim necessitamos de um tradutor ou compilador e o que usaremos será o xc8.

O programa padrão  


//Aula 000 - Configura o hardware para o PIC 18F4550
//Turma: Eletroeletrônica
//Auto: Clodoaldo Silva
//Data: 12/04/2018
//Revisão: 12Abr2018

// INICIA a configuração do microcontrolador 18F4550

#include <xc.h>
#define _XTAL_FREQ 4000000      // Usar sempre que usar delay no programa...

// CONFIG1L
#pragma config PLLDIV = 1       
#pragma config CPUDIV = OSC1_PLL2
#pragma config USBDIV = 1       

// CONFIG1H
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator (HS))
#pragma config FCMEN = OFF    
#pragma config IESO = OFF       

// CONFIG2L
#pragma config PWRT = OFF       
#pragma config BOR = ON         
#pragma config BORV = 3         
#pragma config VREGEN = OFF     

// CONFIG2H
#pragma config WDT = OFF            // Watchdog Timer desabilitado
#pragma config WDTPS = 32768    

// CONFIG3H
#pragma config CCP2MX = ON      
#pragma config PBADEN = ON      
#pragma config LPT1OSC = OFF    
#pragma config MCLRE = ON       

// CONFIG4L
#pragma config STVREN = ON      
#pragma config LVP = ON         
#pragma config ICPRT = OFF      
#pragma config XINST = OFF      

// CONFIG5L
#pragma config CP0 = OFF        
#pragma config CP1 = OFF        
#pragma config CP2 = OFF        
#pragma config CP3 = OFF        

// CONFIG5H
#pragma config CPB = OFF        
#pragma config CPD = OFF        

// CONFIG6L
#pragma config WRT0 = OFF       
#pragma config WRT1 = OFF       
#pragma config WRT2 = OFF       
#pragma config WRT3 = OFF       

// CONFIG6H
#pragma config WRTC = OFF       
#pragma config WRTB = OFF       
#pragma config WRTD = OFF       

// CONFIG7L
#pragma config EBTR0 = OFF      
#pragma config EBTR1 = OFF      
#pragma config EBTR2 = OFF      
#pragma config EBTR3 = OFF      

// CONFIG7H
#pragma config EBTRB = OFF      

// FIM da configuração do microcontrolador 18F4550

// Inicia a configuração dos pinos do microcontrolador

void main (void)

{
LATA=0b00000000;    //limpa todo o portA 
LATB=0b00000000;    //limpa todo o portB
LATC=0b00000000;    //limpa todo o portC
LATD=0b00000000;    //limpa todo o portD
LATE=0b00000000;    //limpa todo o portE

PORTA=0b00000000;    //Coloca o pino para iniciar em zero 
PORTB=0b00000000;    //Coloca o pino para iniciar em zero 
PORTC=0b00000000;    //Coloca o pino para iniciar em zero 
PORTD=0b00000000;    //Coloca o pino para iniciar em zero 
PORTE=0b00000000;    //Coloca o pino para iniciar em zero

//Por hora usaremos somente os Ports A e C

TRISA=0b11111111;    //Configura o PORTC como entrada
TRISC=0b00000000;    //Configura o PORTC como saída 


ADCON1=0b00001111;   //Configura as entradas como digitais (não analógicas)

// FIM da configuração dos pinos do microcontrolador

// Aqui inicia o programa

while(1)  //loop infinito
    {
    //Seu código ficará aqui...
    }
}


Agora é compilar e testar usando o proteus...

Até a próxima aula... 

Controle de LEDs via bluetooth

Ligar Leds a partir de botões e chaves já não é mais novidade. Hoje, todos temos um celular e com uma interface simples podemos acioná-los a distância.

Para tal, precisaremos:
  • Arduino Uno
  • Bluetooth (usei o HC-05)
  • Dois resistores de 150 ohms
  • Dois Leds
  • Uma matriz de contatos irá ajudar nas coneções
  • Um celular com android 
Agora é só seguir o esquema e montar.

O esquema eletrônico


Importante:_______________________________________

Para descarregar o código do arduino o bluetooth não pode estar conectado, pois o canal de comunicação é o mesmo.

Recomendações:___________________________________

Abaixo, segue o código fonte comentado, você pode copiar e colar, ou simplesmente baixá-lo no final da postagem. Más recomendo que leia e após entende-lo faça as alterações que atenderão sua necessidade.

Código do arduino

//----------------------------------
//Site: www.clubedaeletronica.com.br
//Autor:Clodoaldo Silva
//Revisão: 12/07/2019
//-----------------------------------

//definição de variáveis
char caracter;    //variável para armazenamento dos dados
int Pin2 = 2;     //pinos digital 2
int Pin3 = 3;     //pinos digital 3

void setup()
{
  Serial.begin(9600);
  pinMode(Pin2, OUTPUT);
  pinMode(Pin3, OUTPUT);
}

void loop()
{
  if (Serial.available())
  {

    caracter = Serial.read(); //Lê o serial e armazena na variável caracter

    if (caracter == '1')      //Se o valor recebido for 1
      //(dado enviado pelo app - btn_liga)
    {
      digitalWrite(Pin2, HIGH); //Liga a o LED conectado à carga 1
    }

    if (caracter == '2')      //Se o valor recebido for 2
      //(dado enviado pelo app - btn_desliga)
    {
      digitalWrite(Pin2, LOW);  //Desliga o LED conectado à carga1
    }

    if (caracter == '3')      //Se o valor recebido for 3
      //(dado enviado pelo app btn_liga)
    {
      digitalWrite(Pin3, HIGH); //Liga a o LED conectado à carga 2
    }

    if (caracter == '4')      //Se o valor recebido for 2
      //(dado enviado pelo app - btn_liga)
    {
      digitalWrite(Pin3, LOW);  //Liga a o LED conectado à carga 2
    }
  }
}

O aplicativo_______________________________________ 

Se desejar mais, pode criar seus próprios aplicativos usando a plataforma thunkable ou APP inventor. Abaixo, um modelo bem simples.

O código no thunkable





















A tela do Android
A primeira impressão é a que fica, portanto o layout deve ser limpo e não cansar a visão. 



Download dos arquivos 

Código do Arduino (.ino)

Código do APP (APK)
(baixe direto no celular)


Espero ter ajudado ...

"Quando vires um homem bom, tenta imitá-lo; quando vires um homem mau, examina-te a ti mesmo."

Confúcio

Até o proximo ...

Clodoaldo Silva



Exercícios diversos

www.clubedaeletronica.com.br
Notas de aula: Exercícios
Professor: Clodoaldo Silva
Última atualização: Janeiro 2006

Listas  
Exercícios básicos ideais para iniciantes (com gabarito).
Lista 01
Lista 02
Lista 03
Lista 04
Lista 05
Lista 06
Lista 07
Lista 08
Lista 09
Lista 10