WINAVR - COMPILADOR PARA LINGUAGEM "C" PARA MICROCONTROLADORES AVR

O COMPILADOR WINAVR E O MUNDO DO SOFTWARE LIVRE

O mundo do software livre (open source) caminha hoje a passos largos. Muitos são os programadores que se dedicam a criar ferramentas dos mais variados tipos sobre esta definição. O WinAVR é uma destas ferramentas, que nasceu sobre a bandeira do software livre. Trata-se de um compilador para Linguagem C, que inclui em seu pacote o compilador GCC GNU, para a família dos microcontroladores AVR ATMEL.

Muitos acreditam que a principal vantagem na utilização de um software livre esta na sua gratuidade. Claro, está é sim uma grande vantagem. Mas não se pode dizer que ela é a principal. Uma outra grande vantagem está em poder participar do projeto em si, fornecendo informações que venham a melhorar o programa e até mesmo realizando alterações no mesmo.

Obs.: Para participar do desenvolvimento open source é necessário estar cadastrado como desenvolvedor junto a associação de programadores que iniciaram o projeto. Além disso, toda e qualquer alteração deve ser oferecida ao grupo, para que a mesma seja analisada e inserida nas próximas versões.

VANTAGENS E DESVATAGENS DO WINAVR

Saber sobre as vantagens e desvantagens do uso de uma nova ferramenta é sempre benéfico, pois permitirá o desenvolvedor conhecer um pouco mais sobre a mesma. Não é minha intenção promover uma comparação entre compiladores, mas apenas fazer uma breve analise dos itens considerados importantes para todo e qualquer compilador. Na tabela abaixo indico as principais vantagens e desvantagens avaliadas por mim.

Observando atentamente a tabela acima pode-se notar que o número de vantagens é bem maior que o número de desvantagens. Claro que você mesmo chegará as suas próprias conclusões e poderá até enumerar outras vantagens e desvantagens. O que importa mesmo é testar!

Com relação à falta de suporte oficial em nossa língua, isto também não é um agravante que impedirá o uso do compilador por qualquer um sem conhecimento na língua inglesa. Existem alguns grupos de debates na Internet sobre o microcontrolador AVR em nossa língua. Nestes muitos participantes são usuários do WinAVR (e uma outra parcela do BASCOM-AVR). Participar de um destes grupos poderá ajudar. Para encontrar estes grupos recorra aos sites que permitem a criação de tais grupos. Um deles é o Yahoo Grupos. Faça a busca usando palavras chaves “AVR”, “WinAVR”, entre outras.

DOWNLOAD E INSTALAÇÃO

A última versão disponível na Internet, até a inserção deste artigo, era a 20100110. A mesma está (ou estava) disponível em http://sourceforge.net/projects/winavr/files/. Trata-se de um artigo executável com um tamanho médio de 29 MB. Assim é recomendável que você possua comunicação com a Internet através de Banda Larga. Caso contrário (conexão através de linha discada) o download terá de ser feito em horários alternativos visando o melhor aproveitamento de sua linha telefônica e ainda a melhor velocidade de conexão.

Salve o arquivo em uma pasta temporária qualquer. Ao final do download execute o arquivo e siga as instruções. O aplicativo de instalação é bastante simples, mas muito inteligente. Basicamente basta clicar em “Avançar” até a conclusão da instalação.

Após a instalação, o programa criará alguns ícones interessantes (que também estarão disponíveis no menu Iniciar do Windows). Três desses ícones trazem informações interessantes a respeito do WinAVR como o manual do mesmo, por exemplo. Um outro é para um pequeno programa editor de textos (Programmers NotePad), bastante interessante, que permite usar o WinAVR sem o auxílio de uma IDE mais complexa, como o AVR Studio 4 da ATMEL que é um outro método de se obter e usar o WinAVR. Porém, neste artigo eu não farei nenhuma analise do uso do WinAVR dentro do AVR Studio. Se você compreender o funcionamento do compilador (que é o foco deste artigo) não terá nenhum problema em usá-lo dentro da IDE AVR Studio..

Não será necessário configurar nada neste momento. O aplicativo de instalação do WinAVR já providenciou as configurações necessárias para o uso do compilador. Fácil não é?

PRIMEIRO PROJETO COM PROGRAMMERS NOTEPAD

Para ajudá-lo no seu primeiro contato com o compilador nada melhor que um passo a passo para um primeiro projeto não é mesmo? Sendo assim, vamos aos passos do mesmo:

- Criação do Projeto;
- Criação do(s) arquivo(s) fonte para o projeto;
- Geração do arquivo MakeFile para compilar o projeto usando o aplicativo MFile;
- Compilação do projeto.

CRIANDO O PROJETO COM O PROGRAMMERS NOTEPAD

Como dito anteriormente o editor de programas presente no WinAVR é o Programmers NotePad. Trata-se de um editor de textos com recursos focados no uso de compiladores.

Abra o aplicativo Programmers NotePad. No menu File -> New -> Project entre com os dados solicitados (nome do projeto e subdiretório onde o mesmo deve ser armazenado).

Obs.: É prudente você separar seus projetos em subdiretórios distintos. Isso ajuda na manutenção do projeto além dos backups. Deixarei a organização de tais subdiretórios por conta de cada um.

Agora você poderá ver, na tela do deu PC, na janela à esquerda intitulada Projec”, logo abaixo de New Project Group o nome dado ao seu projeto. Pronto o projeto está criado. Vamos adicionar um arquivo fonte para o mesmo.

CRIANDO UM ARQUIVO PARA O CÓDIGO FONTE

Para criar um arquivo “fonte” use o menu File -> New -> C / C++. Você precisa agora digitar um programa.Lembre-se apenas que qualquer erro cometido durante a digitação podrá impedir você  de realizar seu primeiro teste com sucesso. Assim, se você achar melhor, eu inseri um arquivo fonte logo abaixo para ajudá-lo. Marque-o (seleção total do fonte), copie e cole para a tela intitulada New. Em seguida salve o novo arquivo, na pasta do projeto, através do menu File -> Save As. Use o nome que achar mais adequado para seu arquivo, mantendo a extensão “.C” (nome_do_arquivo.c). Evite nome com espaços e caracteres especiais. Use como exemplo o nome dado para nosso exemplo. Após salvar o arquivo é hora de incluí-lo ao projeto. Clique com o botão direito sobre o nome do seu projeto, na janela Projects e em seguida selecione o arquivo (que deve ser exatamente o que está aberto na tela do aplicativo e salvo no subdiretório do projeto).

//***********************************************************************
// Programa teste_winAVR.c - Desenvolvido para testar o compilador WIN AVR
// Deenvolvido por Márcio José Soares
// Compilador WIN AVR
// Microcontrolador: ATMEGA16
// Clock de operação: 1 Mhz (interno)
//***********************************************************************


//#define __AVR_ATmega16__

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>

typedef unsigned char  uint8;
typedef unsigned short uint16;
typedef unsigned long  uint32;


//***********************************************************************
// Definições para o módulo
//***********************************************************************
#define TRUE 1

//***********************************************************************
// Funções do módulo
//***********************************************************************

//***********************************************************************
// Função de delay - aguarda aproximadamente 1 segundo
// Trabalha com espera ocupada e tem baixa precisão. Depende também do
// clock configurado para o microcontrolador - 1 MHz
//
// Entradas - nenhuma
// Saídas   - nenhuma
//***********************************************************************
void delay(void){

   uint8 a;
   uint16 b;

   for (a = 0; a<200; a++)
      for (b=0; b<10000; b++)
         ;
}

//***********************************************************************
// Função principal - MAIN
//***********************************************************************
int main(void){

   PORTB = 0x01;		 	// liga pull-up em PB0
   DDRB  = 0xFE;		 	// porta configurada como saída, exceto PB0
  
   PORTD = 0x00;		 	// sem pull-ups
   DDRD  = 0xFF;		 	// porta configurada como saida 
   
   PORTD = 0x01;                 	//liga PD1

   while (TRUE){
      if (PINB & 0x01){ 
         delay();		      	//temporiza
	 if (PORTD < 0x80)
	    PORTD = PORTD << 0x01;    	//faz deslocamento do bit
	 else			      	//se chegou no fim
 	    PORTD = 0x01;	      	//inicia novamente 
      }
      else{
         delay();		      	//temporiza
	 if (PORTD > 0x01)
	    PORTD = PORTD >> 0x01;    	//faz deslocamento do bit
	 else	 		      	//se chegou no fim
	    PORTD = 0x80;	      	//inicia novamente 
      }
   }
   return (0);	
}

GERANDO O ARQUIVO MAKEFILE COM O APLICATIVO MFILE

Você precisa agora gerar o arquivo MakeFile. Este arquivo será utilizado para a compilação do código fonte e link-edição com as bibliotecas. Para os usuários e programadores em ambiente Linux, o uso deste tipo de arquivo não é nenhum segredo, mas o mesmo é pouco comum para os usuários do Windows.

Junto com o WinAVR foi instalado o aplicativo Mfile [WinAVR]. Este aplicativo permite gerar de forma rápida e segura o arquivo MakeFile. Abra este aplicativo através do ícone criado na área de trabalho do Windows ou ainda através do menu “Iniciar”. Ele se apresentará como na figura abaixo.

Insira o nome do arquivo main a ser compilado através do menu MakeFile -> Main File name. Você deve digitar o nome do seu arquivo fonte principal sem a extensão “.C”. Não insira a extensão citada ok!

O Mfile imediatamente após a confirmação do nome do arquivo irá inserir o nome digitado no arquivo MakeFile que é mostrado em sua tela (PC). Sempre que uma alteração for feita no arquivo, a mesma será demonstrada.

Em seguida selecione a CPU (microcontrolador) no qual você vai gravar o programa. O meu exemplo foi desenvolvido para usar o microcontrolador ATMEGA16. Para selecionar o microcontrolador indicado use o menu MakeFile -> MCU Type -> ATmega -> atmega16.

Salve o arquivo no subdiretório do projeto sem alterar seu nome (Makefile) usando o menu File -> Save As. Feche o aplicativo Mfile. Você não precisará mais dele. Abra o arquivo Makefile com o próprio Programmers NotePad e altere a frequência do microcontrolador. Basta deixar a parte nomeada como Processor frequency do arquivo como está abaixo.

# Processor frequency.
#     This will define a symbol, F_CPU, in all source code files equal to the 
#     processor frequency. You can then use this symbol in your source code to 
#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
#     automatically to create a 32-bit value in your source code.
#     Typical values are:
           F_CPU =  1000000
#         F_CPU =  1843200
#         F_CPU =  2000000
#         F_CPU =  3686400
#         F_CPU =  4000000
#         F_CPU =  7372800
#         F_CPU =  8000000
#         F_CPU = 11059200
#         F_CPU = 14745600
#         F_CPU = 16000000
#         F_CPU = 18432000
#         F_CPU = 20000000
#         F_CPU = 8000000

Você deve ter notado que o menu do programa Mfile possui outras opções. Estude a documentação do WinAVR para compreender o que estas podem fazer por seu projeto, caso tenha esta curiosidade.

COMPILANDO O PROJETO

A esta altura você já tem um projeto pronto para ser compilado. A compilação do mesmo é bastante simples e feita através do editor Programmers NotePad, menu Tools – [WinAVR] MakeAll. Se tudo correr bem na janela Output será apresentada uma mensagem conforme abaixo.

> "make.exe" all

-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Size before:
AVR Memory Usage
----------------
Device: atmega16

Program:     182 bytes (1.1% Full)
(.text + .data + .bootloader)


Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)

Size after:
AVR Memory Usage
----------------
Device: atmega16

Program:     182 bytes (1.1% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)

-------- end --------
> Process Exit Code: 0
> Time Taken: 00:00

A informação Exit Code: 0 é importante. Com ela você poderá saber qual erro ocorreu durante a compilação do seu projeto. O código “0” informa que a compilação foi um sucesso. Para confirmar isso, basta abrir o sub-diretório do projeto e verificar a presença do arquivo nome_do_arquivo_fonte.HEX. O arquivo HEX é o resultado da compilação. É este arquivo que será gravado no microcontrolador.

Como curiosidade você poderá abrir o arquivo nome_do_arquivo_fonte.lss que contém a “conversão” das instruções da linguagem C para a linguagem Assembly. A grande maioria dos compiladores C desenvolvidos para microcontroladores gera tal arquivo (às vezes com extensões diferentes).

Este arquivo ajuda o desenvolvedor a “medir” o grau de otimização do compilador e é muito útil para encontrar um bug do compilador ao “traduzir” um determinado comando da linguagem C para a Linguagem Assembly. É claro que para nestes casos são necessários conhecimentos em ambas as linguagens de programação.

CIRCUITO DE TESTES

Na figura abaixo você tem um circuito para testar o programa o oferecido aqui neste artigo.

Minha sugestão é que o circuito seja montado em uma matriz de contatos. Não ofereci nenhum lay-out para a confecção de um circuito impresso, pois o intuito do artigo não foi oferecer uma montagem, mas sim um passo a passo para uso do compilador WinAVR.

Após a montagem do circuito você deverá gravar o microcontrolador. Para isso eu poderia recomendar o uso do gravador ET-AVR1, em conjunto com o programa PonyProg ou mesmo AVRDUDE. Todas as informações necessárias sobre a montagem do gravador e seu uso em conjunto com o programa PonyProg foram passadas no referido artigo.

CONCLUSÃO

A leitura (e por que não re-leitura) deste artigo permitirá a fixação dos passos necessários no uso inicial do compilador e suas ferramentas. Esta também ajudará a sanar toda e qualquer dúvida que, por ventura, possa surgir. Uma boa documentação está presente no subdiretório de instalação do WinAVR e é recomendável também a sua leitura. Com um pouco de prática e dedicação você estará muito em breve utilizando o compilador WinAVR com bastante facilidade. Até a próxima!