Ambiente para programação em linguagem assembly no Lixux

Como o Linux se tornou um sistema operacional definitivo e está presente no controle de servidores em quase todas as áreas de negócios ao redor do mundo, os usuários comuns, como nós, também passaram a usar o Linux adotando uma de suas diversas distribuições como Fedora, Ubuntu, Debian, Mint, entre outras.

Usar Linux no dia a dia já deixou de ser uma realidade somente reservada a especialista pois hoje existem interfaces gráficas que podem até superar aquela do seu concorrente, sem contar a estabilidade do sistema, a segurança contra ataques de vírus, a disponibilidade do sistema para o usuário, isto é, "ligou o sistema, a máquina é sua". Além disso o usuário é livre para escolher entre várias distribuições e um variado número de interfaces gráficas, desde as mais leves, que permitem operar em computadores mais lentos, até as mais sofisticadas.

O problema mais difícil, para quem se acostumou com o 'concorrente', é vencer o medo da mudança e, talvez, não querer abandonar o investimento feito com as licenças dispendiosas e compras de softwares proprietários.

Para quem programa microcontroladores, talvez não seja tão difícil fazer essa mudança e, para isso, vamos apresentar aqui a configuração de um ambiente de programação.

Os exemplos aqui apresentados serão baseados na distribuição Fedora que tem um gerenciador de pacotes chamado DNF. No Debian ou no Ubuntu, o gerenciador de pacotes é o APT. Outras distribuições podem usar outros gerenciadores.

Requisitos

O ambiente proposto aqui tem os seguintes requisitos:

• Todos os comandos devem ser executados dentro do diretório do usuário
• Pacote GPUTILS instalado no Linux
• Programa MPLAB IPE instalado no Linux
• Gravador de PIC modelo PICKit3
• Um microcontrolador PIC16F628A para teste do exemplo

Instalação dos Requisitos

Instalação do pacote 'GPUTILS'

Abrir um terminal Linux e não sair do diretório do usuário.

Esse pacote vai instalar o compilador e o linker.
Para instalar esse pacote, abrir o terminal do Linux e digitar o comando:

sudo dnf install gputils

Uma vez instalado, digitar no terminar o comando:

gpasm -v

Deverá aparecer uma resposta como:

gpasm-1.5.2 #1325 (Jan 16 2026)

Digitar o comando:

gplink -v

Deverá aparecer uma resposta como:

gplink-1.5.2 #1325 (Jan 16 2026)

Instalação do MPLAB IPE

Para gravar o arquivo executável no microcontrolador será usado o programa 'MPLAB IPE' que deverá ser instalado seguindo os passos abaixo.

Entrar na página da Microchip e, na caixa de pesquisa, logo no início da página, pesquisar por 'mplabx'.

A pesquisa vai levar a uma página de resultado onde aparece o link abaixo.

Clicar sobre esse link para ir a página de download.

Uma vez na página de download, rolar a tela, procurar pela versão Linux e fazer o download.
Será baixado um arquivo de nome parecido com 'MPLABX-v6.30-linux-installer.tar'.

Criar um diretório como, por exemplo:
mkdir mplab

Mover o arquivo baixado para o diretório criado:
mv MPLABX-v6.30-linux-installer.tar mplab

Descomprimir o arquivo com o comando:
tar -xvf MPLABX-v6.30-linux-installer.tar

A descompressão criará o arquivo 'MPLABX-v6.30-linux-installer.sh' que já deve ter premissão de execução.
Se não tiver permissão, use o comando:
chmod 755 MPLABX-v6.30-linux-installer.sh

Iniciar a instalação com o comando:
sudo ./MPLABX-v6.30-linux-installer.sh

Tela de setup

Clicar em "Avançar"

Tela de licença.

Checar a opção "I accept the agreement" e, em seguida, clicar em "Avançar" para prosseguir.

Tela de escolha do diretório de instalação

Não modificar e apenas clicar "Avançar".

Tela de escolha de aplicações que serão instaladas.

Como o objetivo aqui é apenas usar o gravador, vamos selecionar apenas as opções "MPLAB IPE" e "8-bit MCUs" mas, se quiser, pode deixar todas elas marcadas para instalação, porém, isso pode consumir muito espaço do HD (veja o espaço usado ao lado de cada opção dessa tela).
Clicar em "Avançar" para continuar a instalação.

Tela de confirmação.

Clicar em "Avançar" para instalar.

Tela de aviso

A tela abaixo avisa que em alguns sistemas operacionais pode ser necessário reiniciá-lo (boot) para que o programa possa ser executado.
Clicar em "OK" para continuar.

Tela final

Clicar em "Finish" para encerrar a instalação.

Processos envolvidos na programação

1. Desenvolvimento do código fonte

2. Compilação do código fonte e geração do arquivo executável

3. Gravação do arquivo executável no microcontrolador

Desenvolvimento do código fonte

Desenvolver o código fonte é responsabilidade do programador ou do projetista que tem uma idéia para implementar no microcontrolador e isso não é objeto deste artigo. A única ressalva é que vamos tratar apenas de programação em linguagem assembly.

Compilação do código fonte e geração do arquivo executável

Vamos agora compilar um programa assembly para ver se funciona.

Criar um diretório: mkdir picprograms

Entrar no diretório: cd picprograms

Criar um arquivo para colocar o programa: touch pisca.asm

Abrir o arquivo 'pisca.asm' com um editor de texto qualquer.

Colar o programa da caixa de texto abaixo no arquivo aberto no editor de textos e salvar o arquivo.

; ------------------------------------------------------------------------ ; Pisca um ou varios LEDs conectados a qualquer porta do microcontrolador ; ------------------------------------------------------------------------ list p=16f628a ; list directive to define processor #include <p16F628A.inc> ; errorlevel -302 ; suppress message 302 from list file ; __CONFIG _CP_OFF & _LVP_OFF & _BOREN_OFF & _MCLRE_ON & _WDT_OFF & _PWRTE_OFF & _INTOSC_OSC_NOCLKOUT ; __CONFIG _CP_OFF & _LVP_OFF & _BOREN_OFF & _MCLRE_ON & _WDT_OFF & _PWRTE_OFF & _HS_OSC ; UDATA 0x20 CBLOCK 0x20 ; Início da RAM do usuário no PIC16F628A REG_DELAY1 ; Registrador para o loop interno REG_DELAY2 ; Registrador para o loop externo ENDC RESET_VECTOR CODE 0x0000 goto inicio INT_VECTOR CODE 0x0004 retfie ; MAIN CODE ; Subrotina de Delay de 100ms delay_ms: MOVLW d'130' ; Carrega o valor do loop externo MOVWF REG_DELAY2 LOOP_EXTERNO: MOVLW d'255' ; Carrega o valor do loop interno MOVWF REG_DELAY1 LOOP_INTERNO: NOP ; Gasta 1 ciclo (opcional, para ajuste fino) DECFSZ REG_DELAY1, F ; Decrementa e pula se for zero (1 ciclo se não pula, 2 se pula) GOTO LOOP_INTERNO ; Gasta 2 ciclos se voltar DECFSZ REG_DELAY2, F ; Decrementa o loop externo GOTO LOOP_EXTERNO RETURN ; Retorna da subrotina (2 ciclos) ; --------------------------------------------------------------------------------------- ; CONFIGURACOES INICIAIS ; --------------------------------------------------------------------------------------- inicio movlw 0x07 movwf CMCON clrf PORTA clrf PORTB bsf STATUS,RP0 movlw 0x00 movwf TRISA movwf TRISB bcf STATUS,RP0 ; loop movlw 0xFF movwf PORTA movwf PORTB movlw .60 call delay_ms movlw 0x00 movwf PORTA movwf PORTB movlw .60 call delay_ms goto loop END

Compilar o program usando o comando:

gpasm -L -eON -c pisca.asm

As mensagens do compilador poderão ser visualizadas no arquivo 'pisca.lst' no mesmo diretório.
Abrir o arquivo 'pisca.lst' para conferir se tudo deu certo.

Gerar o arquivo executável usando o comando:

gplink -cm pisca.o -o pisca

Vai aparecer somente a seguinte mensagem:

message: Using default linker script "/usr/share/gputils/lkr/16f628a_g.lkr".

As mensagens do resultado da geração do arquivo executável estarão gravadas no arquivo 'pisca.map'.
Abrir esse arquivo para visualizar as mensagens.

Gravação do arquivo executável no microcontrolador

Antes de iniciar o processo de gravação,

1. Desligar o circuito do microcontrolador.
2. Conectar o cabo USB do gravador na porta USB do computador.
3. Conectar o cabinho de 6 fios aos pinos de programação ICSP do microcontrolador.
4. Ligar o circuito do microcontrolador.

Iniciar o MPLAB IPE

Durante a inicialização essa tela irá aparecer informando a carga dos módulos.

Configurações iniciais

Na tela principal abaixo, abrir o menu 'Settings' e selecione a opção 'Advanced Mode' para fazer Login no modo avançado.

Login e Release from Reset

Fornecer a senha 'microchip' que é a senha default de instalação e, a seguir, acionar o botão 'Log in'

Abrir o menu 'Settings' novamente (ver figura 9) e checar a opção 'Release from Reset'.
Essa opção permite que o microcontrolador comece a funcionar assim que o programa for gravado.
Se a opção 'Hold in Reset' estiver selecionada, o microcontrolador permanecerá em estado de 'Reset' até que a opção 'Release from Reset' seja selecionada.

Seleção do microcontrolador e gravador

Na janela principal (figura 11 abaixo) digitar, na caixa de texto da lista 'Device', o nome do microcontrolador que está sendo usado no projeto (PIC16F628A).
Abrir a lista 'Too' e selecionar o programador (PICKit3).
Acionar o botão 'Connect' para o 'MPLAB IPE' se conectar ao programador 'PICKit3'.

Avisos durante conexão

Ao conectar, o 'MPLAB IPE' mostra uma janela de aviso para rertificar-se que o microcontrolador usado opera a 5V ou 3.3V (ver figura 12 abaixo).
Acionar o botão 'OK'.

Se a conexão ocorreu bem, a área de mensagens do 'MPLAB IPE' apresentará as seguintes mensagens:

Seleção do programa para gravação

Na tela principal (figura 9) digitar, na caixa de texto 'Hex_File:', o caminho completo (diretório) onde se localiza o arquivo executável.
Acionar o botão 'Browse' para abrir a janela de seleção de arquivos.
Selecionar o arquivo desejado (.hex) e acionar o botão 'Abrir'.
A figura 14 mostra a área de mensagens para confirmar a carga do programa.

Gravação do programa no microcontrolador

Na tela principal (figura 9) acionar o botão 'Program' para transferir o arquivo executável para o microcontrolador.
Ao terminar a gravação, observar as mensagens emitidas na área de mensagens.
Neste ponto, se tudo correu bem, o microcontrolador já deve estar operando.

Shell para automação do processo de compilação

A fim de automatizar o processo de compilação, sugerimos usar o script Shell abaixo que fará a compilação e a geração do arquivo executável.

Este script mostrará, também, as mensagens de compilação e geração do executável, facilitando a correção de erros quando houver.

No diretório do usuário (/home/usuario), criar um novo diretório para armazenar scripts Shell usando o comando:

mkdir shell

Entrar no diretório criado:

cd shell

Criar um novo arquivo para conter o script Shell de automação:

touch pic_compile

Abrir o arquivo criado num editor de textos qualquer, arrastar e copiar o código da janela abaixo, colar dentro do arquivo aberto no editor e, em seguida, salvar o arquivo.

Atribuir permissões de execução para o arquivo com o comando:

chmod 755 pic_compile

Para acessar o Shell de qualquer localização do sistema, fazer um link simbólico usando o comando:

sudo ln -s /home/usuario/shell/pic_compile /usr/local/bin/pic_compile

Para executar uma compilação, voltar no diretório onde se encontra o arquivo fonte:

cd ../picprograms

Executar o script de compilação fornecendo o nome do arquivo fonte sem especificar a extensão:

pic_compile <nome_do_fonte_sem_extensao>

#!/bin/sh # ------------------------------------------------------------------------------ # pic_compile # # Automacao de compilacao de programas assembly para microcontroladores PIC. # # Chamada: pic_compile <arquivo_fonte> (sem extensao .asm) # # ------------------------------------------------------------------------------ clear echo "Compilando programa assembly" echo "Removendo arquivos velhos..." rm -f *.cod *.cof *.lst *.map *.o echo "Arquivos velhos (cod, cof, lst and map) removidos" echo "Compilando..." gpasm -L -eON -c $1.asm gplink -cm $1.o -o $1 if test -f "$1.map"; then echo echo "$1.map file listing" head -30 $1.map echo echo "COMPILATION SUCCESSFUL" else echo echo "COMPILATION ERROR" fi # Deixa somente os arquivos .hex .map e .lst rm -f *.cod *.cof *.o echo "END OF JOB" echo

Observações sobre o hardware

Usando o PICkit3 como fonte de alimentação do circuito

Antes de usar isto, certificar-se de quanta corrente o circuito alimentado vai necessitar e comparar com a capacidade de fornecimento de corrente da porta USB do computador.

1. Conectar o PICkit3 na porta USB
2. Conectar os pinos de saída do PICkit3 nos pinos ICSP do circuito a ser programado
3. Iniciar o MPLABX IPE
4. Dar Login: "Settings"->"Advanced Mode" usar senha "microchip"
5. Na tela "Operate", selecionar o microcontrolador e o programador "PICkit3"
6. Clicar em "Power" no menu do lado esquerdo da tela
7. Na tela "Power settings", marcar a opção "Power target circuit from PICkit"
8. Manter a tensão em 5V
9. Na aba "Operate", acionar "Connect"
   Se aparecer a mensagem dizendo que o VDD é insuficiente, voltar ao menu "Power", diminuir a tensão e tentar "Connect" novamente. Repetir isso até consiguir conectar o programador.

Usando uma fonte externa para alimentar o circuito

Este modo é o recomendado.

1. Alimentar o circuito com uma fonte externa
2. Conectar o PICkit3 na porta USB
3. Conectar os pinos de saída do PICkit3, inclusive o VDD, nos pinos ICSP do circuito a ser programado
4. Iniciar o MPLABX IPE
5. Dar Login: "Settings"->"Advanced Mode" usar senha "microchip"
6. Na tela "Operate", selecionar o microcontrolador e o programador "PICkit3"
7. Clicar em "Power" no menu do lado esquerdo da tela
8. Na tela "Power settings", desmarcar a opção "Power target circuit from PICkit"
9. Manter a tensão em 5V
10. Na aba "Operate", acionar "Connect"
    Se aparecer a mensagem dizendo que o VDD é insuficiente, voltar ao menu "Power", diminuir a tensão e tentar "Connect" novamente. Repetir isso até consiguir conectar o programador.

Notas sobre as características do circuito

Para evitar erros de programação, principalmente nos chips 16F, recomenda-se o seguinte:

1. Sempre dar preferência pela alimentação do circuito com uma fonte externa para não forçar a drenagem de corrente da porta USB.

2. O microcontrolador sempre deve ter um capacitor de 100nF entre os pinos Vdd e Vss.

3. Os fios ou trilhas que levam as saídas do Pickit3 aos pinos de programação ICSP devem ser curtos.

4. Se durante a conexao o MPLAB-IPE emitir a mensagem:
   
   "Target Device ID (0x0) is an Invalid Device ID. Please check your connections to the Target Device."
   
   Conectar um resistor pull-up de 10k ao pino PGD.
   Se nao funcionar com o resistor pull-up, tentar com pull-down.
   O que se notou é que, quando consegue conectar com um resistor pull-up ou pull-down, pela primeira vez, pode-se retirar o resistor e continuará funcionando nas conexões subsequentes.

---