Microchip: MPLAB X e MPLAB XC – parte 1

 

Licença Creative Commons
Microchip: MPLAB X e MPLAB XC – parte 1 por Fábio Souza. Esta obra está sob a licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Artigo publicado originalmente no site Embarcados

destaque-660x236

Um bom conjunto de ferramentas de desenvolvimento de firmware é essencial para produtividade e um bom aproveitamento dos recursos do microcontrolador que se está trabalhando. Uma IDE que traga recursos para edição e depuração de código agiliza bastante o desenvolvimento de código para microcontroladores, quando se está trabalhando com projetos mais complexos. Pensando nisso a Microchip[1] atualizou a consagrada MPLAB IDE para a poderosa IDE MPLAB X [2].

O objetivo do MPLAB X é ser o único ambiente de denvolvimento necessário para se trabalhar com a linha de microcontroladores da Microchip [1]. Essa IDE trouxe muitas mudanças para as ferramentas de desenvolvimento para os microcontroladores PIC. Ao contrário da ferramenta anterior, MPLAB IDE, que foi desenvolvida totalmente pela Microchip, o MPLAB X é baseado em uma ferramenta de código aberto, o Netbeans [3], tornando as ferramentas da Microchip multiplataforma, e pode ser utilizada em Windows, Linux ou Mac OS.

A figura 1 exibe a janela inicial do MPLAB X. Para quem conhece o ambiente Netbeans, nota-se rapidamente a semelhança:

inicio_MPLABX-660x350

MPLAB X trouxe muitos recursos que auxiliam o desenvolvedor em seus projetos. Confira a seguir uma breve lista de recursos apresentados:

  • Possui visualização gráfica para código mais complexos, podendo visualizar facilmente as chamadas de funções e dependências de códigos;
  • Possibilidade de diversas configurações em um mesmo projeto como: compiladores (várias versões do mesmo compilador), ferramentas de gravação e depuração;
  • Hiperlinks para fácil navegação no códigos;
  • Templates de códigos para auxiliar na produtividade;
  • Visualização de alteração no código desde a última modificação;
  • Expansão de macros;
  • Dois tipos de janela de disassembly;
  • Auto complete de código;
  • Controle de versão;
  • Entre outros.

A Microchip trás também em seu conjuntos de ferramentas o compilador C, MPALAB XC [4]. Este é um poderoso compilador para toda a linha de microcontroladores PIC. Possui versão para os microcontroladores de 8, 16 e 32 bits, conhecidas como XC8, XC16 e XC32. Este compilador possui diferentes tipos de licenças, inclusive uma grátis. cada licença possui diferentes niveis de otimização, conforme exibido na figura 2 a seguir:

optimization-levels

Conforme se pode observar na figura 2, a versão free não possui otimização de código, porém pode-se avaliar por 60 dias a versão pro. A versão Standard possui 50% de otimização e a versão PRO 100%.

No próximo artigo vamos criar uma aplicação do zero usando as ferramentas apresentadas. Será necessário fazer o download do MPLAX X [2] e a versão MPLAB XC8 [4], já que focaremos nos microcontroladores de 8 bits da Microchip [5]. Deve-se ficar atento ao sistema operacional que está utilizando para fazer o correto download.

Caso tenha dificuldade com a instalação do MPLAB X, você pode acompanhar o passo a passo de instalação, para cada sistema operacional, na página Developer Helps [6].Para a instalação do MPLAB XC 8, também é apresentado um passo a passo no link a seguir [7].

 Referências

[1] – http://www.microchip.com

[2] – http://www.microchip.com/pagehandler/en-us/family/mplabx/

[3] – https://netbeans.org

[4]- http://www.microchip.com/pagehandler/en-us/devtools/mplabxc/home.html

[5]- http://www.embarcados.com.br/microchip-microcontroladores-8-bits/

[6]- http://microchip.wikidot.com/mplabx:installation

[7]- http://microchip.wikidot.com/xc8:installation

Crédito das Imagens: Microchip [1].

Publicado em PIC

Comunicação Serial com C# e Arduino – Parte 1

Uma interface entre o arduino e um computador muitas vezes é importante durante o desenvolvimento de projeto ou para controle de dispositivos através de uma interface gráfica. Pode-se usar uma aplicação no computador para Aquisição e exibição de dados em forma de gráfico durante algum experimento em laboratório ou estudo. Como já foi visto aqui no artigo sobre o Arduino Uno e sobre comunicação Serial com Arduino, a comunicação entre a placa e o computador é feira através de uma porta serial emulada através do driver da USB. Já foi exibido aqui uma aplicação de comunicação serial desenvolvida com a plataforma JAVA. Neste artigo vamos ensinar como desenvolver uma aplicação para Windows usando a plataforma .Net usando o ambiente Visual Studio da Microsoft, com a linguagem C#. Será desenvolvido um terminal simples, onde se poderá enviar e receber caracteres através de uma interface gráfica. Esse artigo também servirá de base para desenvolvermos uma aplicação envolvendo botões e outros elementos visuais.

Você pode baixar a versão express dessa ferramenta diretamente no site da plataforma. Selecione a opçãoExpress 2013 for Windows Desktop. Após o download faça a instalação, que é um processo bem simples porém um pouco demorado, basta seguir os passos de instalação.

Ao Iniciar o Visual Studio será exibida sua tela inicial e para iniciar um novo projeto deve-se acessar o menuFILE > New Project. Como vamos trabalhar com a linguagem C#, deve-se selecionar a opção Visual C# no menu lateral. Agora vamos iniciar o passo a passo pra criar nossa aplicação:

01

Primeiro passo é iniciar um novo projeto Windows Forms Application em C#:

02

Agora vamos inserir os componentes no Form. O primeiro a ser inserido será um botão e deve-se mudar a sua propriedade Name para “btConectar” e a sua propriedade Text para “Conectar”, conforme exibido a seguir:

03

Inserir um comboBox logo a frente do botão btConectar, inserido anteriormente:

04

Inserir outro botão, logo abaixo do btConectar, e mudar a sua propriedade Text para “Enviar” e Name para btEnviar:

05

Agora vamos inserir um textBox, que receberá os dados a serem enviados. Após ser inserido, mudar a sua propriedade Name para “textBoxEnviar”:

06

Agora vamos inserir um textBox maior, que exibirá os dados recebidos. Mudar as propriedades Name para “textBoxReceber”, Multiline para “True” e ScrollBar para “Vertical”. A aparência do Form ficará da seguinte forma:

07

Próximo passo é inserir um componente timer que será responsável pela atualização das portas COM disponíveis no PC. Selecione o componente timer e clique dentro do Form. Será exibido logo abaixo o componente timer1. Troque a propriedade Name para “timerCOM” e Interval para 1000, conforme exibido a seguir:

08

Por último vamos inserir o componente de comunicação serial, o SerialPort. Selecione o componente SerialPort e depois clique dentro do Form. Será exibido este componente ao lado do timerCOM:

09

Com os componentes inseridos no Form, vamos para a codificação.

Antes de conectar a porta Serial, é necessário verificar as portas COMs disponíveis para uso, e qual a porta o usuário deseja conectar. Para isso vamos atualizar a cada segundo a ComboBox com as portas disponíveis. Vamos criar um método privado dentro da classe Form1, que será chamado de atualizaListaCOMs. Clique com o botão direito no Form e selecione a opção View code. Insira o método atualizaListaCOMs(), conforme exibido no código a seguir:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports; 	// necessário para ter acesso as portas
namespace interfaceArduinoVS2013
{
    public partial class Form1 : Form
    {
    	public Form1()
    	{
        	InitializeComponent();
    	}
    	private void atualizaListaCOMs()
    	{
        	int i;
        	bool quantDiferente;	//flag para sinalizar que a quantidade de portas mudou
        	i = 0;
        	quantDiferente = false;
        	//se a quantidade de portas mudou
        	if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
        	{
            	foreach (string s in SerialPort.GetPortNames())
            	{
                	if (comboBox1.Items[i++].Equals(s) == false)
                	{
                    	quantDiferente = true;
                	}
            	}
        	}
        	else
        	{
            	quantDiferente = true;
        	}
        	//Se não foi detectado diferença
        	if (quantDiferente == false)
        	{
            	return;                     //retorna
        	}
        	//limpa comboBox
        	comboBox1.Items.Clear();
        	//adiciona todas as COM diponíveis na lista
        	foreach (string s in SerialPort.GetPortNames())
        	{
            	comboBox1.Items.Add(s);
        	}
        	//seleciona a primeira posição da lista
        	comboBox1.SelectedIndex = 0;
    	}
	}
}

Para testar a aplicação é necessário clicar no botão Start ou pressionar a tecla F5. Se tiver alguma porta disponível para comunicação, esta será listada dentro da comBox, conforme exibido a seguir:

08testeAtualizaCOM

 

 

Na imagem acima nota-se que apenas a COM5 estava disponível. Caso uma placa Arduino seja inserida, é necessário que atualize automaticamente a lista. Para isso vamos usar o timerCOM que está configurado para gerar um evento a cada segundo. Inicialmente deve-se habilitar o timer logo após a inicialização do Form e colocar o método de atualização dentro do evento timerCOM_tick, conforme exibido a seguir:

Obs.: Para gerar o evento timerCOM_tick basta dar duplo clique no componente timerCOM na aba design.

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;  // necessário para ter acesso as portas
namespace interfaceArduinoVS2013
{
    public partial class Form1 : Form
    {
    	public Form1()
    	{
        	InitializeComponent();
        	timerCOM.Enabled = true;
    	}
    	private void atualizaListaCOMs()
    	{
        	int i;
        	bool quantDiferente;	//flag para sinalizar que a quantidade de portas mudou
        	i = 0;
        	quantDiferente = false;
        	//se a quantidade de portas mudou
        	if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
        	{
      	      foreach (string s in SerialPort.GetPortNames())
            	{
                	if (comboBox1.Items[i++].Equals(s) == false)
                	{
                    	quantDiferente = true;
                	}
            	}
      	  }
        	else
        	{
            	quantDiferente = true;
        	}
        	//Se não foi detectado diferença
        	if (quantDiferente == false)
        	{
            	return;                     //retorna
        	}
        	//limpa comboBox
        	comboBox1.Items.Clear();
        	//adiciona todas as COM diponíveis na lista
        	foreach (string s in SerialPort.GetPortNames())
        	{
            	comboBox1.Items.Add(s);
        	}
            //seleciona a primeira posição da lista
        	comboBox1.SelectedIndex = 0;
    	}
    	private void timerCOM_Tick(object sender, EventArgs e)
    	{
        	atualizaListaCOMs();
    	}
	}
}

Insira outro Arduino ou crie uma porta COM virtual para verificar que é atualizado automaticamente o comboBox:

09timerAtualizaCOMs-660x325

No exemplo acima foi criada uma COM virtual com o auxílio do programa VSPE, que pode ser baixado aqui.

Agora já se pode escolher em qual porta a aplicação vai conectar. O evento click do btConectar será usado para  fazer a conexão. Para criar esse evento, selecione a aba de design do Form e dê um duplo clique no botão conectar. Será gerado o evento e agora deve-se  inserir o código para conexão. O botão conectar também servirá para desconectar quando a porta já estiver conectada, confira o código a seguir:

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;  // necessário para ter acesso as portas
namespace interfaceArduinoVS2013
{
    public partial class Form1 : Form
    {
    	public Form1()
    	{
        	InitializeComponent();
        	timerCOM.Enabled = true;
    	}
    	private void atualizaListaCOMs()
    	{
        	int i;
        	bool quantDiferente;	//flag para sinalizar que a quantidade de portas mudou
        	i = 0;
        	quantDiferente = false;
        	//se a quantidade de portas mudou
        	if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
        	{
            	foreach (string s in SerialPort.GetPortNames())
            	{
                	if (comboBox1.Items[i++].Equals(s) == false)
                	{
                    	quantDiferente = true;
                	}
            	}
        	}
        	else
        	{
            	quantDiferente = true;
        	}
        	//Se não foi detectado diferença
        	if (quantDiferente == false)
        	{
            	return;                     //retorna
        	}
        	//limpa comboBox
            comboBox1.Items.Clear();
        	//adiciona todas as COM diponíveis na lista
        	foreach (string s in SerialPort.GetPortNames())
        	{
            	comboBox1.Items.Add(s);
        	}
        	//seleciona a primeira posição da lista
        	comboBox1.SelectedIndex = 0;
    	}
    	private void timerCOM_Tick(object sender, EventArgs e)
    	{
        	atualizaListaCOMs();
    	}
    	private void btConectar_Click(object sender, EventArgs e)
 	   {
        	if (serialPort1.IsOpen == false)
        	{
            	try
            	{
                	serialPort1.PortName = comboBox1.Items[comboBox1.SelectedIndex].ToString();
                	serialPort1.Open();
            	}
            	catch
            	{
                	return;
            	}
            	if (serialPort1.IsOpen)
            	{
                	btConectar.Text = "Desconectar";
                	comboBox1.Enabled = false;
     	       }
        	}
        	else
        	{
            	try
            	{
                	serialPort1.Close();
                	comboBox1.Enabled = true;
                	btConectar.Text = "Conectar";
            	}
    	        catch
            	{
                	return;
            	}
        	}
    	}
	}
}

10testConectar

 

É necessário colocar uma proteção para que o programa não seja fechado e deixe a porta COM aberta, dessa forma impedindo que outros programas possam usá-la. Para isso vamos fechar a porta dentro do evento Form1_FormClosed:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;  // necessário para ter acesso as portas
namespace interfaceArduinoVS2013
{
    public partial class Form1 : Form
    {
    	public Form1()
    	{
        	InitializeComponent();
 	       timerCOM.Enabled = true;
    	}
    	private void atualizaListaCOMs()
    	{
        	int i;
        	bool quantDiferente;	//flag para sinalizar que a quantidade de portas mudou
        	i = 0;
        	quantDiferente = false;
        	//se a quantidade de portas mudou
        	if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
        	{
            	foreach (string s in SerialPort.GetPortNames())
            	{
                	if (comboBox1.Items[i++].Equals(s) == false)
                	{
                    	quantDiferente = true;
                	}
            	}
        	}
        	else
        	{
            	quantDiferente = true;
        	}
        	//Se não foi detectado diferença
        	if (quantDiferente == false)
        	{
            	return;                     //retorna
        	}
        	//limpa comboBox
        	comboBox1.Items.Clear();
        	//adiciona todas as COM diponíveis na lista
        	foreach (string s in SerialPort.GetPortNames())
        	{
            	comboBox1.Items.Add(s);
        	}
        	//seleciona a primeira posição da lista
        	comboBox1.SelectedIndex = 0;
    	}
 	   private void timerCOM_Tick(object sender, EventArgs e)
    	{
        	atualizaListaCOMs();
    	}
    	private void btConectar_Click(object sender, EventArgs e)
    	{
        	if (serialPort1.IsOpen == false)
        	{
     	       try
            	{
                	serialPort1.PortName = comboBox1.Items[comboBox1.SelectedIndex].ToString();
                	serialPort1.Open();
            	}
            	catch
            	{
                	return;
                }
            	if (serialPort1.IsOpen)
            	{
                	btConectar.Text = "Desconectar";
                	comboBox1.Enabled = false;
            	}
        	}
        	else
        	{
            	try
            	{
                	serialPort1.Close();
                	comboBox1.Enabled = true;
                	btConectar.Text = "Conectar";
            	}
            	catch
            	{
                	return;
         	   }
        	}
    	}
    	private void Form1_FormClosed(object sender, FormClosedEventArgs e)
    	{
        	if(serialPort1.IsOpen == true)  // se porta aberta
         	serialPort1.Close();        	//fecha a porta
    	}
	}
}

O processo para conexão e fechamento da porta serial já está feito, e o próximo passo é fazer o programa enviar para o Arduino o que for digitado dentro do textBoxEnviar. Para isso, dentro do evento btEnviar_Click, deve-se inserir o seguinte código:

private void btEnviar_Click(object sender, EventArgs e)
{
if(serialPort1.IsOpen == true) //porta está aberta
serialPort1.Write(textBoxEnviar.Text); //envia o texto presente no textbox Enviar
}

A recepção de dados requer um pouco mais de atenção. Inicialmente deve-se criar um evento serialPort1_DataReceived e uma variável global do tipo String. O processo de recepção acontece em uma Thread diferente da atualização dos componentes. A atualização do textBoxRebecer deve ser feita fora do evento de recepção da serial. Para isso criamos uma função trataDadoRecebido. Confira como ficará o código completo da aplicação:

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using System.IO.Ports; // necessário para ter acesso as portas
 namespace interfaceArduinoVS2013
 {
 public partial class Form1 : Form
 {
 string RxString;
 public Form1()
 {
 InitializeComponent();
 timerCOM.Enabled = true;
 }
 private void atualizaListaCOMs()
 {
 int i;
 bool quantDiferente; //flag para sinalizar que a quantidade de portas mudou
 i = 0;
 quantDiferente = false;
 //se a quantidade de portas mudou
 if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
 {
 foreach (string s in SerialPort.GetPortNames())
 {
 if (comboBox1.Items[i++].Equals(s) == false)
 {
 quantDiferente = true;
 }
 }
 }
 else
 {
 quantDiferente = true;
 }
 //Se não foi detectado diferença
 if (quantDiferente == false)
 {
 return; //retorna
 }
 //limpa comboBox
 comboBox1.Items.Clear();
 //adiciona todas as COM diponíveis na lista
 foreach (string s in SerialPort.GetPortNames())
 {
 comboBox1.Items.Add(s);
 }
 //seleciona a primeira posição da lista
 comboBox1.SelectedIndex = 0;
 }
 private void timerCOM_Tick(object sender, EventArgs e)
 {
 atualizaListaCOMs();
 }
 private void btConectar_Click(object sender, EventArgs e)
 {
 if (serialPort1.IsOpen == false)
 {
 try
 {
 serialPort1.PortName = comboBox1.Items[comboBox1.SelectedIndex].ToString();
 serialPort1.Open();
 }
 catch
 {
 return;
 }
 if (serialPort1.IsOpen)
 {
 btConectar.Text = "Desconectar";
 comboBox1.Enabled = false;
 }
 }
 else
 {
 try
 {
 serialPort1.Close();
 comboBox1.Enabled = true;
 btConectar.Text = "Conectar";
 }
 catch
 {
 return;
 }
 }
 }
 private void Form1_FormClosed(object sender, FormClosedEventArgs e)
 {
 if(serialPort1.IsOpen == true) // se porta aberta
 serialPort1.Close(); //fecha a porta
 }
 private void btEnviar_Click(object sender, EventArgs e)
 {
 if(serialPort1.IsOpen == true) //porta está aberta
 serialPort1.Write(textBoxEnviar.Text); //envia o texto presente no textbox Enviar
 }
 private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
 {
 RxString = serialPort1.ReadExisting(); //le o dado disponível na serial
 this.Invoke(new EventHandler(trataDadoRecebido)); //chama outra thread para escrever o dado no text box
 }
 private void trataDadoRecebido(object sender, EventArgs e)
 {
 textBoxReceber.AppendText(RxString);
 }
 }
 }
 

Para testar a aplicação junto ao Arduino, vamos fazer o upload do seguinte sketch:

[language code=”cpp”]
void setup()
{
Serial.begin(9600); //inicia comunicação serial com 9600
}
void loop()
{
if(Serial.available()) //se algum dado disponível
{
char c = Serial.read(); //le o byte disponivel
Serial.write(c); //retorna o que foi lido
}
}
[/code]

Nesse programa o Arduino simplesmente retornará o dado que ele receber. Dessa forma, quando enviarmos dados pelo programa, estes serão exibidos no computador por meio do textBoxRecebe. A figura abaixo exibe os dados enviados e recebidos pela aplicação:

11testeComunicação

 

Agora que a aplicação está completa, ou seja, já conseguimos enviar e receber dados, vamos a um exemplo funcional. Conforme foi exibido no Artigo sobre comunicação serial no Arduino, vamos aproveitar o exemplo que acenderá o led através do comando vindo pela serial. Carregue o seguinte exemplo no Arduino:

[language code="cpp"]
 /*
 * comandos via serial
 * inverte o estado do led conctado a saída 13 do arduino quando recebe o caracter 'A' pela serial
 */
 const int LED = 13;
 void setup() {
 Serial.begin(9600); //configura comunicação serial com 9600 bps
 pinMode(LED,OUTPUT); //configura pino do led como saída
 }
 void loop() {
 if (Serial.available()) //se byte pronto para leitura
 {
 switch(Serial.read()) //verifica qual caracter recebido
 {
 case 'A': //caso 'A'
 digitalWrite(LED,!digitalRead(LED)); //inverte estado do LED
 break;
 }
 }
 }
 [/code]

Execute a aplicação, conectando a porta na qual o Arduino está ligado e envie o caractere ‘A’. Verifique o resultado no LED conectado ao pino 13 da placa Arduino:

 

12testeArduino-660x315

O download da aplicação completa pode ser feito através do link: Aplicação C# para interface serial com Arduino.

 

 Conclusão

 

A ferramenta Visual Studio da Microsoft permite criar facilmente uma interface de comunicação Serial entre o Arduino e um computador (com sistema operacional Windows). A partir do exemplo apresentado, pode-se fazer aplicações para enviar e receber comandos para o Arduino ou outro dispositivo conectado a uma porta serial. No próximo artigo vamos fazer uma aplicação envolvendo botões e outros componentes que deixarão nossa interface mais elegante.

 

 

Para aprender mais

 

Comunicação Serial Java + Arduino

 

 

Referências

 

Comunicação serial Arduino
SerialPort Class
Classe SerialPort

 

Esse artigo foi publicado originalmente no site Embarcados e é de autoria de Fábio Souza.

Licença Creative Commons
Comunicação Serial com C# e Arduino – Parte 1 por Fábio Souza. Esta obra está sob a licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Marcado com: , ,
Publicado em ARDUINO

Arduino: Expandindo os I/Os – Parte 1

 

Licença Creative Commons
Arduino: Expandindo os I/Os – Parte 1 por Fábio Souza. Esta obra está sob a licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.
74hc138

 

Muitas vezes em um desenvolvimento de projeto com Arduino UNO ocorre o problema de os pinos não serem suficientes para sua aplicação. A alternativa muitas vezes é a troca por outro Arduino com maior quantidade de pinos, como por exemplo o Arduino MEGA. Porém essa troca aumenta muito o custo do projeto, já que se vai usar um Arduino com maior capacidade de memória e outros recursos, onde essas características não são os problemas em seu projeto.

Neste artigo vamos apresentar alguns circuitos integrados que podem aumentar a quantidade de entradas e saídas, dando maiores possibilidades ao seu projeto sem a necessidade de trocar o microcontrolador ou a plataforma de desenvolvimento, como por exemplo, uma Arduino UNO por um Arduino MEGA.

Existem diversos CIs que podem ser utilizados para essa aplicação. Neste artigo vamos abordar apenas alguns para aumentar a quantidade de saídas, focando na técnica utilizada para a expansão com exemplos.

Vamos iniciar com o 74HC138, que é um decodificador / demultiplexador de alta velocidade. Com esse CI pode-se expandir os pinos de 3 para 8 saídas, porém só é possível acionar uma saída por vez. Pode se utilizar para aplicações onde necessite de acionamento de uma saída por vez, um sequencial de saídas por exemplo. Outra aplicação seria a varredura de displays de 7 segmentos. A seguir é apresentada a ligação desse CI ao Arduino UNO.

Arduino_74HC138-660x487Para escolha da saída (Y0 –  Y7) é necessário fazer a combinação nas entradas A, B e C com o endereço em binário, onde A é o bit menos significativo. Note que a saída é ativa em nivel 0. Veja a tabela verdade desse CI:

tabela-verdade-74hc138-660x323

Para exemplificar o uso do 74HC138, vamos aproveitar o esquemático apresentado e criar um programa para acionamento das saídas em intervalos de 1 segundo:

const byte PIN_A = 4; // PINO A do 74HC138
const byte PIN_B = 3; // PINO B do 74HC138
const byte PIN_C = 2; // PINO A do 74HC138
byte i =0; //variável para controle da escrita no 74HC138
void setup()
{
pinMode(PIN_A, OUTPUT); //configura como saída
pinMode(PIN_B, OUTPUT); //configura como saída
pinMode(PIN_C, OUTPUT); //configura como saída
}
void loop()
{
ligaSaida(i); //liga saida i
delay(1000); //aguarda 1 segundo
i++; //incrementa i
if(i>7) i=0; //se i passou de 7 reinicia com 0
}
void ligaSaida(int x) //função para acionamento do 74hc138
{
switch(x)
{
case 0: //saida 0
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,LOW); //0
break;
case 1: //saida 1
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,LOW); //0
break;
case 2: //saida 2
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,LOW); //0
break;
case 3: //saida 3
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,LOW); //0
break;
case 4: //saida 4
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,HIGH); //1
break;
case 5: //saida 5
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,HIGH); //1
break;
case 6: //saida 6
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,HIGH); //1
break;
case 7: //saida 7
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,HIGH); //1
break;
 }
}

Outra opção interessante para expandir o número de saídas de um microcontrolador é o uso do CI 74HC595. Trata-se de um registrador de deslocamento, ou seja, um conversor serial para paralelo de 8 bits. Neste CI os bits são inseridos um a um até completar o byte, e depois é enviado um comando para atualização das saídas. Diferentemente do 74HC138, com este CI podemos acionar qualquer saída a qualquer momento. Ele pode ser utilizado para expandir os pinos do microcontrolador para acionamentos de reles, display LCDs e uma infinidade de aplicações. São necessários apenas 3 pinos do microcontrolador para controle das saídas, conforme exibido na figura abaixo:

Arduino_74HC595-660x387

No pino 14 será onde inserimos o bit a ser deslocado, já no pino 11 será o pulso de clock e quando os 8 bits forem inseridos é dado um pulso no pino 12 para escrever na saídas. Abaixo é exibida a tabela verdade e o diagrama de tempo para funcionamento do 74HC595:

tabela-verdade-74hc595-660x345

diagrama-de-tempo-74hc595-660x366

Para exemplificar vamos aproveitar o esquemático apresentado e criar um programa para acionamento das saídas, escrevendo valores de 0 a 255:


int latchPin = 7;  //ST_CP of 74HC595
int clockPin = 8; //SH_CP of 74HC595
int dataPin =  9;  // DS of 74HC595
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
void loop() {
  for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
    digitalWrite(latchPin, HIGH);
    delay(500);
  }
}

 Conclusão

O uso de CI digitais para a expansão de saídas no Arduino pode ser uma opção interessante quando a quantidade de portas torna-se limitada em uma placa Arduino. Aliado com um boa biblioteca você pode facilmente acionar saídas ampliando as possibilidades da sua placa. O CI 74HC595 é uma ótima opção para a expansão de pino e pode-se ligar outros e aumentar a quantidade para 16 saídas. No próximo artigo vamos apresentar alguns CIs para aumentar a quantidade de entradas em seu Arduino.

 Referências

Serial to Parallel Shifting-Out with a 74HC595

Microcontroller input / output expander

Marcado com: ,
Publicado em ARDUINO

O impacto do Arduino no mundo do embarcados – TDC2014

A plataforma Arduino esta cada vez mais presente em projetos de sistemas embarcados, seja para estudo ou para aplicações comerciais. As placas arduino estão em constantes desenvolvimento e já deixou de ser um plataforma simples baseada apenas em microcontroladores de 8 bits. Hoje existe uma grande variedades de placas Arduino que vão desde microcontroladores de 8 bits a microcontroladores de 32 bits com núcleo ARM. Conhecer essa plataforma de hardware e software é de grande importância para o profissional da área de sistemas embarcados, onde é possível aprender e aplicar diversas tecnologias de uma forma fácil e divertida, além de participar da comunidade open source.

Confira a apresentação da #TrilhaEmbedded #TDC2014 #fbseletronica #embarcados #Arduino

Marcado com: , ,
Publicado em ARDUINO

” Todos neste país deveriam aprender a programar um computador… porque isto ensina você a pensar” ____Steve Jobs

Esse video mostra a opinião dos maiores programadores da historia. Bill Gates, Mark Zuckerberg, will.i.am, Chris Bosh, Jack Dorsey, Tony Hsieh, Drew Houston, Gabe Newell, Ruchi Sanghvi, Elena Silenok, Vanessa Hurst, and Hadi Partovi. Dirigido por Lesley Chilcott.

“Everybody in this country should learn to program a computer… because it teaches you how to think”.    ____Steve Jobs

Publicado em LOGICA DE PROGRAMAÇÃO

Google Glass caseiro com Arduino.

Confira o video onde o garoto de 13 anos usou a plataforma Arduino Esplora e uma tela de LCD para fazer o Google Glass.

fonte: http://www.tecmundo.com.br/google-glass/59223-jovem-13-anos-cria-google-glass-caseiro-arduino.htm

Publicado em CURIOSIDADES

Software Freedom Day

O evento Arduino Day 2014 foi um sucesso agora e agora vem  o SFD (Software Freedom Day) este evento também mundial que ajuda a entender a filosofia de Software Livre. É um evento mundial e ocorrerá  em diversas cidades brasileiras. Será dia 20 de setembro de 2014. Para mais informações confira no site e participe desta edição em um local mais próximo a você.

http://softwarefreedomday.org/

 

SFD

 

Publicado em CURIOSIDADES
%d blogueiros gostam disto: