25 novembro 2013

Gravador AVR USBasp

Hoje vou falar de uma placa para quem gosta de "escovar bits", como se dizia (não tão) antigamente : o Gravador AVR USBasp.

Este gravador, como o próprio nome diz, é utilizado para programar microcontroladores Atmel AVR. É composto por uma pequena placa, com conector USB, um ATMega8 e mais uns poucos componentes, utilizando um driver genérico para comunicação com o computador. Abaixo, o gravador que eu usei para criar este post :


Gravador AVR USBasp


O gravador USBasp permite a programação de microcontroladores em baixo nível, inclusive mexendo na configuração de fuse bits, lock bits, clock e outras configurações que podem otimizar o desempenho do seu microcontrolador... ou travá-lo. Sim, nos testes eu consegui "travar" uns 2 microcontroladores, mas pretendo recuperá-los em breve. Portanto, tenha cuidado ao mexer nas configurações mais avançadas. :-)

Hoje, vou utilizar o USBasp para programar o ATmega328P. Existem vários tutoriais na internet sobre como utilizar o USBasp para programar esse microcontrolador usando o próprio Arduino Uno, mas o que este tutorial vai mostrar é como programar diretamente o microcontrolador, utilizando um programa gerado na IDE do Arduino.

Como esse tutorial é um pouco extenso, vou separá-lo em seções. Vamos aos passos :
  1. - Instalação do USBasp e seus drivers
  2. - Criação do programa na IDE do Arduino
  3. - Geração do arquivo HEX à partir do programa criado na IDE
  4. - Instalação do programa Extreme Burner AVR para gravação do Microcontrolador
  5. - Ligação do USBAsp no ATMEGA328P
  6. - Gravar no ATMEGA328P o programa HEX gerado no passo 3
  7. - Teste do ATMEGA328P no Arduino Uno
Material a ser utilizado :

  • 3 leds, de preferência de cores diferentes
  • 3 Resistores de 330 ohms ou valores compatíveis com os leds
  • 1 Chip ATmega328P
  • 1 Módulo Gravador AVR USBasp

1 - Instalação do gravador USBasp e seus drivers

O procedimento abaixo foi testado no Windows 7 (64 bits) com Service Pack 1, e também no Windows XP, logo não deve apresentar problemas nas demais versões do Windows. Para Linux e MacOS, não há necessidade de drivers.

O gravador USBasp pode ser conectado diretamente na porta USB do computador, porém, antes de plugar o dispositivo, recomendo o download do driver , nesse link :

http://www.fischl.de/usbasp/usbasp-windriver.2011-05-28.zip

Descompacte o arquivo e será gerada uma pasta chamada usbasp-windriver.2011-05-28. Plugue o USBasp e, após o dispositivo ser detectado pelo Windows, escolha "PROCURAR SOFTWARE DE DRIVER NO COMPUTADOR". Indique a pasta que foi descompactada e o driver será instalado automaticamente. No painel de controle do seu computador, em GERENCIADOR DE DISPOSITIVOS, será mostrado um novo dispositivo chamado USBasp :

Gerenciador de dispositivos - USBasp

2 - Criação do programa na IDE do Arduino

Carregue este programa exemplo no Arduino, que acende e apaga 3 leds em sequencia, com intervalos de 1 segundo :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Programa : Teste USBasp  
// Autor : Arduino e Cia  
   
int pinoledvermelho =3;  
int pinoledverde = 4;  
int pinoledamarelo = 5;  
   
void setup()  
{  
  pinMode(pinoledvermelho, OUTPUT);  
  pinMode(pinoledverde, OUTPUT);  
  pinMode(pinoledamarelo, OUTPUT);  
}  
   
void loop()  
{  
  digitalWrite(pinoledvermelho, HIGH);  
  delay(1000);  
  digitalWrite(pinoledvermelho, LOW);  
  digitalWrite(pinoledverde, HIGH);  
  delay(1000);  
  digitalWrite(pinoledverde, LOW);  
  digitalWrite(pinoledamarelo, HIGH);  
  delay(1000);  
  digitalWrite(pinoledamarelo, LOW);  
  delay(1000);  
}  

3 - Geração do arquivo HEX à partir do programa criado na IDE

O programa que vamos utilizar para gravar o microcontrolador, o Extreme Burner AVR, não aceita, por exemplo, que um arquivo .INO seja carregado diretamente e  gravado no microcontrolador. Para isso, será necessário gerar um arquivo com extensão HEX (formato hexadecimal). Esse arquivo HEX, por sua vez, será convertido pelo Extreme Burner para 0s e 1s, ou seja, o formato que o microcontrolador "entende".

Por padrão, esse arquivo HEX não é criado quando você compila um programa na IDE, mas com uma pequena mudança na configuração da IDE, podemos gerar esse arquivo no computador.

Entre na IDE do Arduino, em ARQUIVO, depois em PREFERÊNCIAS :

IDE Arduino - Preferencias

 Escolha EXIBIR MODO VERBOSO, conforme destacado :

IDE Arduino - Modo verboso selecionado

Clique em OK e volte para a IDE, compilando o programa. Na parte inferior da janela, serão exibidas várias informações, e nas últimas linhas, o local em que o programa gerou o arquivo HEX. Note que no seu computador esse caminho provavelmente será diferente :

IDE - Compilacao caminho arquivo HEX

Anote/copie essa informação sobre o local do arquivo, pois ela será utilizada daqui a pouco.

4 - Instalação do programa Extreme Burner AVR para gravação do microcontrolador

Essa parte vai dar um pouco mais de trabalho, pois exige a mudança de alguns arquivos de configuração, já que o programa Extreme Burner AVR não possui o microcontrolador ATmega328P em sua lista de chips, e precisaremos inserí-lo manualmente. O programa pode ser baixado nesse link  e tem versões para Windows e Linux. Nos meus testes usei a versão 1.4.2 do programa.

A instalação é bem simples. Execute o arquivo extreme_burner_avr_v1.4.2_setup.exe (ou a versão que você baixou), confira as informações sobre a pasta de instalação e criação de ícones no desktop, e o programa será instalado. Ignore a instalação do driver no final do processo, mantendo o driver do USBasp que você instalou no passo 1.

Depois de instalado, precisamos adicionar o chip ATmega328P à lista de chips suportados pelo Exreme Burner. Para isso, vá até a pasta de instalação, normalmente em C:\Program Files\Extreme Burner -AVR\Data, e abra o arquivo chips.xml. Pode ser usado o próprio notepad para isso, mas certifique-se que você tem as permissões de administrador para abrir o arquivo.

No final do arquivo chips.xml, insira as seguintes linhas :

 <CHIP>
      <NAME>ATmega328P</NAME>
      <FLASH>32768</FLASH>
      <EEPROM>1024</EEPROM>
      <SIG>0x000F951E</SIG>
      <PAGE>128</PAGE>
      <LFUSE layout="2">YES</LFUSE>
      <HFUSE layout="5">YES</HFUSE>
      <EFUSE layout="4">YES</EFUSE>
      <LOCK>YES</LOCK>
      <CALIB>YES</CALIB>
      <PLACEMENT>.\Images\Placements\ZIF_DIP_40.bmp</PLACEMENT>
   </CHIP>

Seu arquivo chips.xml deve ficar mais ou menos assim, com a alteração em destaque :

Chips.xml alterado

Salve o arquivo e abra o Extreme Burner. Na aba CHIP, certifique-se que o controlador ATmega328P aparece no final da lista :

Extreme Burner - Chip ATmega328P adicionado

5 - Ligação do USBasp no microcontrolador

Hora de ligarmos o USBasp no microcontrolador que será programado. Com o USBasp desplugado da USB, efetue as seguintes conexões, seguindo o esquema de ligação :

Ligação USBasp - ATmega328p

Pinagem ATmega328p

Esta configuração está de acordo com a pinagem da placa que estou usando, e o seu módulo pode ser um pouco diferente, mas basta seguir o esquema de ligação acima. Fique atento à tensão de alimentação do microcontrolador (pino VCC do USBasp), que no meu caso é 5v, mas em outros módulos USBasp pode ser configurado para 3.3 ou 5v.

6 - Gravar no ATmega o programa HEX gerado no passo 3

Com o programa HEX gerado, o caminho do arquivo anotado e as ligações ao microcontrolador conferidas e reconferidas, vamos à gravação. Conecte o USBasp na porta USB do seu computador, abra o Extreme Burner, e clique em OPEN, no lado esquerdo da tela....

Extreme Burner - Tela Principal

... e vá até a pasta que você anotou no passo 3, abrindo o arquivo HEX :

Extreme Burner - Selecionando arquivo

Clique em OPEN e, na parte superior da janela do programa, será mostrado o caminho do arquivo HEX que foi carregado :

Extreme Burner - Arquivo HEX carregado

Para finalizar, no menu WRITE, escolha FLASH, e aguarde o final do processo de gravação, que deve mostrar uma tela como essa :

Extreme Burner - Gravação finalizada

7 - Teste do ATmega328P gravado

Para testar o ATmega328P que foi gravado, simplesmente coloque o chip no Arduino UNO, montando o seguinte circuito :

Circuito teste ATmega328P


Desta maneira, o programa que foi criado no passo 1 será executado continuamente. Você não precisa necessariamente de uma placa do Arduino para testar. Também é possível montar o circuito externamente, com alguns componentes como cristal, capacitores e resistores.

Note que o chip que foi gravado contém apenas o programa do Arduino, sem o bootloader. Ou seja, se você tentar programar o Arduino UNO com este chip que foi gravado pelo Extreme Burner, não vai conseguir. Outro detalhe é que você pode apagar e reprogramar o chip quantas vezes quiser, usando as funções do Extreme Burner.

Isso é útil quando você precisa de um chip dedicado para o seu projeto, ou então existe a necessidade de gravar microcontroladores em série. Inclusive o USBasp funciona com uma grande variedade de controladores, como você pode ver na tabela abaixo :

USBasp - Microcontroladores suportados


Este foi apenas um exemplo de utilização, pois como comentei no início do post as opções de programação são as mais variadas possíveis. Reforço que deve-se tomar cuidado nas configurações avançadas, evitando danificar/travar o microcontrolador, ok ?

Até a próxima !

11 novembro 2013

Sensor de som Arduino

O assunto hoje do Arduino e Cia é som. Mais precisamente, Sensor de Som.

Já vimos aqui no site como gerar sons a partir do Arduino usando o comando tone. O que eu vou utilizar hoje é esta pequena mas eficiente placa com microfone embutido, que você encontra na FILIPEFLOP, o Sensor de Som Arduino. Com ela, vou mostrar como detectar o som ambiente e como tratar o sinal gerado por esse módulo.

Esta placa, além do microfone, tem um pequeno amplificador embutido (o circuito integrado LM386), pois apenas o microfone não seria capaz de enviar os dados para o Arduino. O esquema de conexão é bem enxuto, composto por apenas 3 pinos : Vcc, GND e S (sinal). No meio da placa, há um potenciômetro para ajuste da sensibilidade.

Sensor de Som Arduino

A placa trabalha com tensão de 5v, e o pino de sinal deve ser ligado de preferência à uma porta analógica do Arduino, já que o sinal gerado é variável, e com isso podemos observar os diferentes níveis de ruído captados pelo microfone.

O circuito de testes será composto pelo módulo Sensor de Som, mais o display LCD Winstar WH1602A, que já abordamos aqui no site, neste artigo. Se você não tem esse display, não se preocupe, pois o programa é facilmente adaptável à outros modelos de displays LCD.

O display, na sua parte superior, vai mostrar o nível do som (Baixo, Médio e Alto), e na parte inferior, será mostrada uma barra que vai acompanhar em tempo real o nível do som detectado pelo microfone :

Sensor de Som - Circuito em funcionamento

O circuito :

Sensor de Som Arduino - Circuito
O programa não utiliza nenhuma biblioteca própria para o módulo sensor de som, já que vamos apenas efetuar a leitura do sinal variável recebido pelo Arduino na porta analógica. Para o display LCD, é utilizada a já conhecida LiquidCrystal.

Para melhorar a precisão do programa, optei por fazer a leitura do sinal 128 vezes, utilizando a variável NUM_LEITURA. Depois, calculo o valor médio e uso este valor para gerar no LCD a indicação de nível de som. O gráfico na linha inferior do display utiliza as informações do sinal em tempo real. Caso você opte por não utilizar o display, os dados também são mostrados no Serial Monitor.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// Programa : Niveis de ruido com Sensor de Som  
// Autor : Arduino e Cia  
   
int num_leitura = 128; //Define o numero de medicoes  
int pinosinal = A0; //Pino ligado ao pino S do modulo sensor de som  
long sinal;   //Armazena o valor lido do Sensor de Som  
long soma = 0; //Armazena o valor total das n medicoes  
long nivel =0; //Armazena o valor medio  
int mostranivel = 0; //Utilizado para gerar o grafico inferior  
int apaga = 0; //Variavel auxiliar para gerar o grafico inferior  
   
#include <LiquidCrystal.h> //Carrega a biblioteca LCD  
   
//Define os pinos que serao ligados ao LCD  
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
   
//Array para montar o simbolo grafico  
byte a[8]=   
{B10000, B11000, B11100, B11110, B11110, B11100, B11000, B10000,};   
   
void setup()  
{   
  pinMode(pinosinal, INPUT); //Define o pino de sinal como Entrada  
  Serial.begin(9600);  
  lcd.begin(16,2); //Inicializa LCD  
  lcd.clear();   //Limpa o LCD  
  lcd.setCursor(0,0); //Posiciona o cursor na coluna 0, linha 0  
  lcd.print("Nivel : ");  
  lcd.createChar(1, a); //Atribui a "1" o valor do array "A",   
                        //que desenha o simbolo grafico  
}  
   
void loop()  
{  
  //Efetua 128 leituras do sinal  
  for (int i=0; i<num_leitura ; i++)  
  {  
    sinal = analogRead(pinosinal);  
    soma = soma + sinal;  
  }  

  nivel = soma/num_leitura; //Calcula o valor medio  
  //Converte o valor lido para um valor entre 0 e 15  
  mostranivel = map(sinal, 0, 500, 0, 15);    
    
  //Gera o grafico inferior  
  for (int i = 0; i<mostranivel; i++)  
  {  
    lcd.setCursor(i,1);  
    lcd.write(1);  
    apaga = 15 - i;  
    for (int x = i; x<15;x++)  
    {  
      lcd.setCursor(x+1,1);  
      lcd.write(" ");  
    }  
  }  
     
  //Verifica o nivel de sinal e exibe na tela    
  if (nivel >0 && nivel < 100)  
  {  
    lcd.setCursor(8,0);  
    lcd.print("Baixo");  
    Serial.print("Nivel Baixo");  
    Serial.print(" - Media : ");  
    Serial.println(nivel);  
  }  

  if (nivel >100 && nivel < 200)  
  {  
    lcd.setCursor(8,0);  
    lcd.print("Medio ");  
    Serial.print("Nivel Medio");  
    Serial.print(" - Media : ");  
    Serial.println(nivel);  
  }  

  if (nivel > 200)  
  {  
    lcd.setCursor(8,0);  
    lcd.print("Alto  ");  
    Serial.print("Nivel alto");  
    Serial.print(" - Media : ");  
    Serial.println(nivel);  
  }  

  soma = 0; //Reinicia a soma dos valores das medicoes  
}  

Lembrando que os valores utilizados como comparação  podem ser ajustados de acordo com o nível de sensibilidade definido pelo potenciômetro.

01 novembro 2013

Ligando motor de passo 28BYJ-48 e ULN2003

Hoje o assunto é o Motor de Passo 28BYJ-48. Já fazia um tempo que eu queria escrever sobre motores de passo, que é um item quase que obrigatório na montagem de robôs. Outros usos incluem relógios, mostradores, painéis ou outros dispositivos que exijam algum tipo de deslocamento.

Atualizado : Veja também o artigo Controlando motor de passo 28BYJ-48 utilizando CustomStepper, onde mostro as funções da biblioteca CustomStepper para controle de ângulo e rotação do motor.

Vamos utilizar este conjunto Motor de passo 28BYJ-48 com driver ULN2003 ,que contém tudo o que você precisa para dar os primeiros passos (ops !) no assunto "motores".

Conjunto motor passo 28BYJ-48 e ULN2003

Um motor de passo funciona aplicando-se tensões específicas a cada uma das bobinas do motor, o que faz com que ele rode no sentido horário ou anti-horário, com maior ou menor velocidade, etc. No datasheet do motor você tem (quase) todas as informações sobre o componente, como por exemplo a disposição das bobinas :
Motor de passo 28BYJ-48 - Bobinas
Imagem : Modmypi

Esse experimento utiliza o módulo controlador com o chip ULN2003 (datasheet), um CI Driver de corrente que permite que, com o Arduino (que suporta corrente máxima de 50 mA por porta), sejam controlados motores que exijam correntes maiores, de até 500 mA. Este módulo aceita alimentação de 5 a 12 volts e possui leds indicadores que mostram o acionamento das bobinas.

Note que o ULN2003 somente auxilia no gerenciamento da tensão e corrente para as portas. Assim, toda a lógica de programação e sequência de bobinas que devem ser acionadas, é controlada pelo Arduino (ou outro microcontrolador que você esteja usando).

Para testes, montei um circuito utilizando dois push-buttons para controlar a rotação do motor. O botão da esquerda move o motor no sentido anti-horário, e o botão da direita, no sentido horário, sem alterar a velocidade:

Circuito motor de passo 28BYJ-48 e ULN2003 Arduino

E finalmente o programa, utilizando como base o exemplo da biblioteca Stepper com algumas alterações para tratamento das funções dos botões :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Programa : Controle de sentido de rotacao de motor de passo  
// Autor : Arduino e Cia  
   
#include <Stepper.h>  
int pinobotao_ah = 3; //Porta botao sentido anti-horario  
int pinobotao_h = 2;  //Porta botao sentido horario  
int passos = 50;      //Passos a cada acionamento do botao  
int leitura = 0;      //Armazena o valor lido do botao horario  
int leitura2 = 0;   //Armazena o valor lido do botao anti-horario  
   
const int stepsPerRevolution = 500;   
 
// Inicializa a biblioteca utilizando as portas de 8 a 11 para  
// ligacao ao motor  
Stepper myStepper(stepsPerRevolution, 8,9,10,11);        
   
void setup()   
{  
  pinMode(pinobotao_h, INPUT);  
  pinMode(pinobotao_ah, INPUT);  
  myStepper.setSpeed(60); //Determina a velocidade do motor  
}  
   
void loop()  
{  
  //Gira o motor no sentido horario  
  leitura = digitalRead(pinobotao_h);   
  if (leitura != 0)
  {
    myStepper.step(-passos);   
  }  

  //Gira o motor no sentido anti-horario  
  leitura2 = digitalRead(pinobotao_ah);  
  if (leitura2 != 0)  
  {  
    myStepper.step(passos);   
  }   
}  

Por último uma observação : este motor possui uma caixa de redução embutida (daí o eixo aparente do motor não estar no centro do mesmo). A falta de algumas especificações das engrenagens da redução geram uma certa confusão na definição dos parâmetros, principalmente no número de passos para uma volta completa, o que exige atenção se você for utilizar este motor em tarefas mais precisas.

Se você tem ou pretende adquirir um motor shield, veja no artigo Controlando motores de passo 28BYJ-48 com o Arduino Motor Shield L293D como controlar 2 motores de passo de uma maneira muito simples.