flowchart TD
A["Código-fonte C\n(.c / .h)"]
B["Compilador XC8\nno MPLAB X IDE"]
C["Arquivo HEX\n(.hex)"]
D["PICSimLab\nSimulação de Hardware"]
E["Simulador MPLAB X\nDepuração de Código"]
F["Periféricos Virtuais\nLEDs, LCD, Botões, Pot"]
G["Ferramentas de Debug\nBreakpoints, Variables, SFRs"]
A --> B
B --> C
C --> D
C --> E
D --> F
E --> G
style D fill:#e8f5e9
style E fill:#e3f2fd
style F fill:#c8e6c9
style G fill:#bbdefb
Apêndice: Simulação e Depuração com PICSimLab e o Simulador do MPLAB X IDE
Considerações Introdutórias
Este apêndice trata de duas ferramentas que desempenham papéis complementares no desenvolvimento de programas para o PIC18F4550: o PICSimLab, que reproduz em software o comportamento dos periféricos físicos da placa ACEPIC PRO V8.2, e o Simulador embutido no MPLAB X IDE, que permite inspecionar variáveis, definir pontos de parada e avançar o código instrução por instrução. A compreensão das capacidades e dos limites de cada ferramenta é importante tanto para que você escolha a mais adequada a cada tipo de investigação quanto para que perceba em que medida a simulação pode efetivamente substituir — e em que medida jamais substituirá — o trabalho com hardware real.
A adoção sistemática de simuladores no ensino e na prática de sistemas embarcados não é um refinamento acessório: reflete uma alteração substancial na maneira como problemas de software embarcado são diagnosticados. Na ausência de ferramentas de simulação, um defeito no código só se manifesta através dos sintomas externos do dispositivo, e o desenvolvedor precisa deduzir a origem do problema a partir dessas manifestações indiretas. Com simuladores, o interior do microcontrolador torna-se observável: variáveis podem ser inspecionadas no momento exato de sua alteração, registradores de periféricos podem ter seus bits acompanhados um a um, e a execução pode ser suspensa em pontos estratégicos para exame minucioso do estado da máquina. Essa transparência acelera drasticamente o diagnóstico de erros lógicos e aprofunda a compreensão do funcionamento interno do dispositivo.
1. O Papel de Cada Ferramenta
Antes de apresentar a operação de cada ferramenta, é importante que você entenda por que ambas são necessárias e quais tipos de problema cada uma resolve melhor. O PICSimLab e o Simulador do MPLAB X não competem entre si; atuam em dimensões distintas do mesmo problema.
O PICSimLab reproduz, com notável fidelidade, o ambiente físico que rodearia o microcontrolador em uma placa real. Você enxerga LEDs acendendo, um display LCD exibindo caracteres, botões passíveis de serem clicados com o mouse, potenciômetros que podem ser girados para variar tensões de entrada, e tudo isso acontece em tempo real, com a aparência e a dinâmica de um hardware concreto. O que o PICSimLab não oferece é o acesso ao interior do programa em execução: não é possível pausar na linha dezesseis do código-fonte C, nem inspecionar o valor de uma variável local naquele instante específico.
Para essa segunda necessidade existe o Simulador do MPLAB X IDE, que executa o mesmo código dentro do próprio ambiente de desenvolvimento, sem qualquer hardware — físico ou simulado — envolvido. Nele, você define breakpoints, avança instrução por instrução, observa como cada variável muda a cada passo da execução e inspeciona o conteúdo dos Registradores de Função Especial do microcontrolador em tempo real. A contrapartida dessa capacidade analítica é a ausência de qualquer representação visual dos periféricos: os LEDs não acendem, os botões não existem como objetos clicáveis, nada acontece no mundo externo ao processador.
O diagrama precedente exibe a convergência das duas ferramentas sobre um mesmo artefato intermediário — o arquivo HEX produzido pela compilação — e as capacidades distintas que cada ramo proporciona. Essa convergência significa, na prática, que você não precisa manter dois códigos-fonte ou dois projetos: um único programa, uma única compilação, atende a ambos os ambientes de verificação. A passagem de uma ferramenta à outra é apenas a escolha do tipo de observação que melhor responde à pergunta que você está fazendo naquele momento.
2. Instalação e Primeiros Passos no PICSimLab
O PICSimLab encontra-se disponível gratuitamente e já vem instalado nas máquinas do laboratório no diretório C:\Program Files\PicsimLab\. Para iniciá-lo, execute o arquivo picsimlab.exe nessa pasta. A janela principal apresenta, entre outros controles, um seletor de placa na barra superior. Entre as opções disponíveis, a que mais se adequa ao propósito deste curso é a placa Spare, nome que alude à ideia de “peças avulsas”: trata-se de uma configuração flexível em que você determina livremente quais componentes estão conectados a quais pinos do microcontrolador. Essa flexibilidade é exatamente o que permite reproduzir, com precisão, o mapeamento de periféricos da ACEPIC PRO V8.2.
Com a placa Spare selecionada, o PICSimLab apresenta uma área de trabalho vazia, onde os componentes virtuais serão posicionados. A escolha do microcontrolador é feita pelo menu Micro, onde você deve selecionar PIC18F4550. A frequência de clock é configurada em Board → Clock, onde o valor correto é 48 MHz, correspondente à frequência gerada pela combinação do cristal externo com o PLL ativado no firmware.
3. Carregamento da Configuração da ACEPIC PRO V8.2
Adicionar cada componente manualmente seria um exercício tedioso e sujeito a erros. Para evitar essa repetição, este apêndice é acompanhado do arquivo acepic_pro_v82.pcf, que descreve de uma só vez todos os periféricos virtuais da placa — os LEDs, o LCD, os botões, o teclado matricial, os potenciômetros e o terminal serial — já posicionados na tela e corretamente conectados aos pinos do PIC18F4550. Esse arquivo segue o formato de descrição de placa utilizado pelo PICSimLab e pode ser editado como texto caso você deseje adicionar ou reposicionar componentes posteriormente.
Com a placa Spare ativa no PICSimLab, acesse o menu File → Load e selecione acepic_pro_v82.pcf. O PICSimLab posicionará automaticamente todos os componentes na área de trabalho, reproduzindo a disposição física dos elementos da ACEPIC PRO V8.2. A tabela a seguir sintetiza a correspondência entre cada componente virtual, o pino do PIC18F4550 a que está ligado e sua função na placa real:
| Componente Virtual | Pino(s) PIC18F4550 | Função na ACEPIC PRO V8.2 |
|---|---|---|
| 8 LEDs (L1–L8) | RD0–RD7 (pinos 23–30) | LEDs de propósito geral |
| LCD 16×2 | RE0=RS, RE1=EN, RD0–RD7=D0–D7 | Display de caracteres |
| Botão B1 | RB0 (pino 33) | Chave de uso geral |
| Botão B2 | RC0 (pino 15) | Chave de uso geral |
| Botão B3 | RA4 (pino 6) | Chave de uso geral |
| Teclado 4×4 | RB0–RB3 (linhas) / RB4–RB7 (colunas) | Teclado matricial |
| Trimpot AN1 | RA0/AN0 (pino 2) | Entrada analógica |
| Trimpot AN2 | RA1/AN1 (pino 3) | Entrada analógica |
| Osciloscópio Ch1 | RC1 (pino 16) | Buzzer, sinal |
| Osciloscópio Ch2 | RC2 (pino 17) | LED PWM |
Conflito de pinos entre LEDs e LCD. Na placa física, os LEDs e o LCD compartilham fisicamente os pinos RD0 a RD7, e essa característica é reproduzida no PICSimLab. Quando um programa escreve dados para o LCD, os LEDs refletem, em tempo real, o estado instantâneo do barramento de dados — comportamento que corresponde exatamente ao que ocorre na placa real. Trata-se, portanto, de fidelidade de simulação e não de defeito. Ainda assim, projetos que pretendam utilizar LEDs e LCD simultaneamente precisam de cuidado adicional para evitar que as escritas destinadas ao LCD produzam efeitos visuais indesejados nos LEDs.
4. Um Programa de Demonstração com Estado Interno
Para que o depurador seja exercitado de maneira significativa, é desejável dispor de um programa que tenha estado interno observável — isto é, variáveis que mudem em resposta a eventos — e uma lógica de controle que valha a pena inspecionar passo a passo. O programa a seguir implementa um contador de 8 bits controlado por dois botões: o botão B1, conectado a RB0, incrementa o contador a cada pressionamento, enquanto o botão B2, conectado a RC0, restaura o contador a zero. O valor corrente do contador é exibido nos LEDs L1 a L8 em representação binária, de modo que o mesmo estado da variável pode ser observado simultaneamente no hardware simulado e na janela de variáveis do depurador.
stateDiagram-v2
[*] --> Aguardando: reset / contagem=0 / LEDs apagados
Aguardando --> Incrementando: B1 pressionado
Aguardando --> Resetando: B2 pressionado
Incrementando --> Aguardando: contagem++ → LEDs atualizam
Resetando --> Aguardando: contagem=0 → LEDs apagados
Incrementando --> Incrementando: contagem == 255\n(overflow para 0)
O diagrama de estados formaliza o comportamento esperado do programa. O estado Aguardando representa o laço principal à espera de um novo evento de botão. A transição para Incrementando ocorre quando B1 é pressionado e produz o incremento da variável de contagem, após o qual o sistema retorna a Aguardando. A transição análoga para Resetando ocorre quando B2 é pressionado, zerando a contagem. O caso particular em que a contagem atinge 255 e sofre novo incremento é representado por uma auto-transição no estado Incrementando, evidenciando que a contagem passa a valer zero em razão do overflow natural do tipo uint8_t.
#include <xc.h>
#include <stdint.h>
/* Configuração dos bits de fusível para 48 MHz
* Cristal externo de 8 MHz na ACEPIC PRO V8.2
* 8 MHz ÷ 2 (PLLDIV) = 4 MHz → PLL × 12 = 48 MHz */
// CONFIG1L
#pragma config PLLDIV = 2 /* 8 MHz / 2 = 4 MHz para o PLL */
#pragma config CPUDIV = OSC1_PLL2 /* 96 MHz PLL / 2 = 48 MHz CPU */
#pragma config USBDIV = 2
// CONFIG1H
#pragma config FOSC = HSPLL_HS /* HS com PLL habilitado */
#pragma config FCMEN = OFF
#pragma config IESO = OFF
// CONFIG2L
#pragma config PWRT = ON
#pragma config BOR = OFF
#pragma config VREGEN = ON
// CONFIG2H
#pragma config WDT = OFF
#pragma config WDTPS = 32768
// CONFIG3H
#pragma config CCP2MX = ON
#pragma config PBADEN = OFF /* PORTB pinos digitais */
#pragma config LPT1OSC = OFF
#pragma config MCLRE = ON
// CONFIG4L
#pragma config STVREN = ON
#pragma config LVP = OFF
#pragma config XINST = OFF
#pragma config DEBUG = OFF
#define _XTAL_FREQ 48000000UL
/* ================================================================
* Variáveis globais — visíveis na janela Variables do MPLAB X
* ================================================================ */
volatile uint8_t contagem = 0; /* Valor exibido nos LEDs (0 a 255) */
volatile uint8_t b1_anterior = 1; /* Último estado lido de B1 (pull-up) */
volatile uint8_t b2_anterior = 1; /* Último estado lido de B2 */
/* Atualiza os LEDs L1-L8 com o valor atual do contador */
void mostrar_leds(void) {
PORTD = contagem;
}
void main(void) {
/* PORTD inteiro como saída (LEDs L1-L8) */
TRISD = 0x00;
PORTD = 0x00;
/* PORTB inteiro como entrada (teclado + botão B1) */
TRISB = 0xFF;
/* Habilita resistores de pull-up internos do PORTB
* Resultado: pino = 1 quando botão está solto,
* pino = 0 quando botão está pressionado */
INTCON2bits.RBPU = 0;
/* RC0 como entrada (botão B2) */
TRISCbits.TRISC0 = 1;
/* Estado inicial das variáveis de debouncing */
b1_anterior = 1;
b2_anterior = 1;
mostrar_leds();
while (1) {
uint8_t b1_atual = PORTBbits.RB0;
uint8_t b2_atual = PORTCbits.RC0;
/* Detecta borda de descida em B1 (solto→pressionado)
* SUGESTÃO DE BREAKPOINT: linha abaixo para observar 'contagem' */
if (b1_atual == 0 && b1_anterior == 1) {
contagem++;
mostrar_leds();
}
/* Detecta borda de descida em B2 (reset)
* SUGESTÃO DE BREAKPOINT: linha abaixo para observar o reset */
if (b2_atual == 0 && b2_anterior == 1) {
contagem = 0;
mostrar_leds();
}
b1_anterior = b1_atual;
b2_anterior = b2_atual;
__delay_ms(10); /* Janela de debouncing de 10 ms */
}
}#include <xc.h>
#include <stdint.h>
#pragma config PLLDIV=2, CPUDIV=OSC1_PLL2, USBDIV=2
#pragma config FOSC=HSPLL_HS, FCMEN=OFF, IESO=OFF
#pragma config PWRT=ON, BOR=OFF, VREGEN=ON
#pragma config WDT=OFF, WDTPS=32768
#pragma config CCP2MX=ON, PBADEN=OFF, LPT1OSC=OFF, MCLRE=ON
#pragma config STVREN=ON, LVP=OFF, XINST=OFF, DEBUG=OFF
#define _XTAL_FREQ 48000000UL
volatile uint8_t contagem = 0;
static uint8_t prev = 0x03; /* bits 0=B1, 1=B2 (ambos soltos=1) */
void main(void) {
TRISD = 0; PORTD = 0;
TRISB = 0xFF; INTCON2bits.RBPU = 0;
TRISCbits.TRISC0 = 1;
while (1) {
uint8_t cur = (PORTBbits.RB0) | (PORTCbits.RC0 << 1);
uint8_t fell = (~cur) & prev; /* bits que caíram (borda de descida) */
if (fell & 0x01) { contagem++; PORTD = contagem; }
if (fell & 0x02) { contagem = 0; PORTD = 0; }
prev = cur;
__delay_ms(10);
}
}A versão otimizada reorganiza a detecção das bordas de descida dos dois botões em uma única operação booleana aplicada a uma palavra de estado de 2 bits, o que elimina os dois testes condicionais independentes da versão didática em favor de uma expressão bitwise aplicada ao conjunto. Ambas as versões preservam o mesmo comportamento observável, mas a otimizada reduz tanto o número de instruções executadas por iteração quanto a pressão sobre o alocador de registradores do compilador.
Configuração da placa antes do teste. Certifique-se de que o jumper JP16-1 encontra-se na posição fechada, o que conecta o botão B1 ao pino RB0, e que o jumper LEDS também está fechado, condição para que os LEDs respondam ao PORTD. As chaves 5 e 6 do DP2 devem estar em ON caso o teclado matricial também esteja em uso, pois habilitam as colunas do teclado sobre RD0 a RD3. Para o programa específico deste apêndice, que não utiliza o teclado, essas chaves podem permanecer em OFF sem prejuízo ao funcionamento.
5. Compilação e Carregamento no PICSimLab
A compilação do programa para uso no PICSimLab segue o mesmo procedimento descrito no apêndice de introdução ao MPLAB X IDE. Certifique-se de que os fusíveis de configuração estão corretamente declarados no código e de que o campo ROM ranges do linker foi configurado com default,-7CFC-7FFF. Manter essa configuração mesmo durante o desenvolvimento com simulação é recomendado porque garante que o código simulado seja idêntico, byte a byte, ao código que virá a ser gravado na placa real, evitando discrepâncias que apareceriam somente no momento da migração para o hardware.
Compile o projeto pressionando F11 para acionar a ação Clean and Build. Ao término, o arquivo .hex resultante estará na pasta dist/default/production/ do seu projeto, pronto para ser carregado no simulador.
Com o PICSimLab aberto e a configuração acepic_pro_v82.pcf previamente carregada, acesse o menu File → Load Hex e selecione o arquivo .hex gerado. O PICSimLab transfere o conteúdo do arquivo para a memória Flash simulada e exibe um resumo da operação. Clique no botão Play, representado pelo triângulo verde na barra de ferramentas, para iniciar a simulação. A partir desse momento, você pode interagir com os componentes virtuais: clique nos botões B1 e B2 na tela do PICSimLab para incrementar e resetar o contador, e observe os LEDs virtuais acenderem e apagarem segundo o padrão binário correspondente ao valor corrente da variável contagem. Os potenciômetros podem ser girados com o mouse para variar a tensão nas entradas analógicas AN0 e AN1 — recurso útil quando o programa envolve leitura do conversor A/D. A janela do osciloscópio no canto inferior do PICSimLab mostra os sinais dos pinos RC1 e RC2 em tempo real, o que permite acompanhar formas de onda geradas por módulos como o PWM.
6. Depuração com o Simulador do MPLAB X IDE
Com o programa funcionando visualmente no PICSimLab, o próximo passo é inspecionar o que acontece no interior do código durante a execução. Para essa finalidade, feche ou pause o PICSimLab e dirija-se ao Simulador embutido no MPLAB X IDE.
6.1 Configuração do Hardware Tool como Simulator
Clique com o botão direito sobre o nome do projeto na janela Projects e selecione Properties. Na árvore à esquerda, expanda Conf:[default] e clique em Connected Hardware Tool. No painel à direita, localize a opção Hardware Tool e selecione Simulator na lista suspensa. Confirme a alteração clicando em Apply e, em seguida, em OK.
A configuração do clock do simulador também precisa ser feita para que os cálculos de tempo sejam corretos. Ainda em Project Properties, clique em Simulator, que aparece logo abaixo da entrada XC8. Em Clock Frequency, informe o valor 48000000 Hz, correspondente à frequência real de operação do microcontrolador. Aplique e confirme com OK.
6.2 Início da Sessão de Depuração
Para compilar e iniciar o depurador simultaneamente, pressione Ctrl+F5 ou clique no ícone do besouro — Debug Project — na barra de ferramentas. O MPLAB X recompila o projeto, carrega o código no simulador e pausa automaticamente na primeira instrução da função main. O cursor verde que aparece no editor indica a linha que será executada no próximo passo do simulador.
Os controles do depurador ficam disponíveis na barra de ferramentas ou podem ser acionados pelos atalhos listados na tabela a seguir:
| Ação | Atalho | O que faz |
|---|---|---|
| Continue | F5 | Executa até o próximo breakpoint ou fim |
| Pause | Shift+F5 | Interrompe a execução no ponto atual |
| Step Over | F8 | Avança uma linha; não entra em funções |
| Step Into | F7 | Avança uma linha; entra dentro de funções |
| Step Out | Shift+F7 | Sai da função atual, volta ao chamador |
| Reset | Shift+F6 | Reinicia a simulação do zero |
| Stop Debug | Shift+F5 | Encerra a sessão de depuração |
6.3 Definição de Pontos de Parada
Um breakpoint é uma marca associada a uma linha específica do código que instrui o simulador a suspender a execução assim que aquela linha for alcançada. Para definir um breakpoint, clique na margem esquerda do editor — a faixa cinza à esquerda dos números de linha — na posição correspondente à linha desejada. Um quadrado vermelho aparecerá indicando a marcação, e o simulador pausará nessa linha nas próximas vezes em que ela for atingida durante a execução.
No programa do contador há três linhas particularmente informativas como pontos de parada. A linha onde ocorre contagem++ é ideal para verificar se o valor da variável foi corretamente incrementado, pois um passo adicional com F8 executa apenas essa operação e permite observar a mudança do valor na janela de variáveis. A linha onde ocorre contagem = 0 cumpre papel análogo em relação ao reset, confirmando que o evento ocorre exatamente no instante em que o botão B2 é detectado. Já a linha PORTD = contagem, no interior da função mostrar_leds, permite confirmar que o registrador PORTD recebe de fato o valor corrente da variável contagem, o que conecta o estado da variável de alto nível ao estado dos pinos de saída físicos.
6.4 Inspeção de Variáveis
A janela de variáveis é acessada pelo menu Window → Debugging → Variables. Ela exibe todas as variáveis locais da função em execução no momento e admite a adição manual de variáveis globais à lista de observação. Para acompanhar continuamente uma variável como contagem, b1_anterior ou qualquer outra, clique com o botão direito sobre o nome da variável no editor e selecione New Watch. A janela Watches — acessível por Window → Debugging → Watches — passa a exibir esses valores permanentemente, ainda que a execução passe por funções distintas. O recurso é especialmente útil quando se deseja acompanhar a evolução de uma variável global ao longo de várias iterações do laço principal sem depender do contexto local de uma função específica.
sequenceDiagram
participant Prog as Programa em execução
participant Sim as Simulador MPLAB X
participant Dev as Você (depurador)
Dev->>Sim: Ctrl+F5 (inicia depuração)
Sim->>Prog: Pausa em main() — cursor verde
Dev->>Sim: F5 (Continue)
Prog->>Prog: Entra no loop while(1)
Prog->>Sim: Atinge breakpoint em contagem++
Sim-->>Dev: Pausa — variável contagem = 7
Dev->>Sim: F8 (Step Over)
Sim->>Prog: Executa contagem++
Sim-->>Dev: contagem = 8 (atualizada na janela)
Dev->>Sim: F8 (Step Over)
Sim->>Prog: Chama mostrar_leds()
Sim-->>Dev: PORTD = 0x08 (visível na janela SFRs)
Dev->>Sim: F5 (Continue)
Prog->>Prog: Aguarda próximo evento...
O diagrama de sequência ilustra a dinâmica típica de uma sessão de depuração do programa do contador. Observe que cada comando do desenvolvedor — iniciar a depuração, continuar a execução, avançar um passo — produz uma alteração controlada no estado do programa, cuja resposta é imediatamente visível nas janelas de variáveis e de SFRs. Esse ciclo de comando e observação é a essência da depuração: transformar uma execução opaca em uma sucessão de estados observáveis.
6.5 Inspeção dos Registradores de Função Especial
Os Registradores de Função Especial, conhecidos na literatura técnica como Special Function Registers (SFRs), são os registradores que controlam diretamente os periféricos do PIC18F4550. O registrador PORTD, por exemplo, reflete o estado elétrico dos pinos correspondentes e, nesta aplicação, controla os LEDs; TRISB define, bit a bit, a direção dos pinos do PORTB como entrada ou saída; INTCON controla os mecanismos de interrupção. Para abrir a janela que exibe o conteúdo desses registradores, acesse Window → PIC Memory Views → SFRs.
Quando o simulador está pausado na linha PORTD = contagem e você pressiona F8 para executá-la, o valor exibido na coluna correspondente a PORTD na janela SFR muda imediatamente para igualar o valor da variável contagem. Essa correspondência visual, frequentemente ignorada por iniciantes, tem valor pedagógico considerável: ela torna evidente que a escrita em um registrador de alto nível é, no microcontrolador, uma modificação direta do estado elétrico dos pinos físicos, sem camadas intermediárias de abstração.
6.6 Simulação de Eventos de Hardware
Uma limitação intrínseca do Simulador do MPLAB X é a ausência de botões, potenciômetros e outros elementos interativos que o PICSimLab oferece. A maneira de simular um botão pressionado é, portanto, alterar manualmente o bit correspondente no registrador de porta. Com o simulador pausado, localize PORTB na janela SFR, clique duas vezes sobre o valor e altere o bit 0, correspondente a RB0, para 0 — essa alteração simula o pressionamento do botão B1. Ao continuar a execução com F5, o programa detectará a transição do pino de 1 para 0 como uma borda de descida e incrementará o contador.
O mesmo procedimento permite forçar qualquer valor em PORTB, PORTC ou em qualquer outro registrador especial, o que viabiliza o teste de condições difíceis de provocar manualmente na placa física. Estados transientes raros, sequências específicas de eventos e combinações improváveis de sinais podem ser reproduzidas com exatidão nessa modalidade de simulação, o que constitui uma das vantagens mais significativas da simulação pura sobre a experimentação com hardware real.
7. Um Fluxo de Trabalho Combinado
O aproveitamento pleno das duas ferramentas exige que você aprenda a alternar entre elas segundo a natureza do problema que está investigando. Um esquema geral do fluxo combinado aparece no diagrama a seguir:
flowchart LR
A["Escrever código\nno MPLAB X"] --> B["Compilar\nF11"]
B --> C{Qual tipo\nde teste?}
C -->|Comportamento\ndo hardware| D["PICSimLab\ncarregar HEX\nobservar LEDs/LCD/botões"]
C -->|Lógica interna\nvariáveis e fluxo| E["MPLAB X Simulator\nCtrl+F5\nbreakpoints e watches"]
D --> F{Funciona?}
E --> F
F -->|Não| A
F -->|Sim| G["Gravar na placa\nvia Bootloader AN1310"]
Na prática, a escolha entre PICSimLab e Simulador do MPLAB X em cada momento depende do tipo de pergunta que você precisa responder. Quando o problema diz respeito ao comportamento externamente observável — os LEDs não acendem como esperado, o LCD exibe caracteres errados, os botões não produzem a resposta desejada — o PICSimLab oferece a visualização mais imediata: você vê o efeito e deduz retroativamente a origem. Quando o problema diz respeito à lógica interna do programa — uma variável está recebendo um valor inesperado, uma condição não está sendo avaliada como o código sugere, um laço está terminando antes do previsto — o Simulador do MPLAB X é a ferramenta adequada, pois permite acompanhar o valor de cada variável em cada instante e entender exatamente como o estado do programa evolui. Em casos mais complexos, ambas as ferramentas são utilizadas em sequência: o PICSimLab localiza o sintoma externo, e o Simulador investiga a causa interna.
8. Diagnóstico de Erros Frequentes
Alguns problemas aparecem com frequência durante o uso combinado das duas ferramentas, e a familiaridade com eles encurta substancialmente o tempo de diagnóstico em situações análogas.
Os LEDs no PICSimLab não respondem ao programa. A causa mais comum é o carregamento de um arquivo HEX desatualizado — você modificou o código-fonte, mas não o recompilou antes de recarregá-lo no PICSimLab. O hábito de sempre pressionar F11 no MPLAB X antes de retornar ao PICSimLab resolve essa categoria inteira de falsos problemas. Outra causa recorrente é o esquecimento da configuração do PORTD como saída — quando TRISD permanece com valor diferente de 0x00, os pinos continuam configurados como entradas e qualquer escrita em PORTD tem efeito nulo sobre os LEDs. Verifique o valor de TRISD na janela SFR do MPLAB X antes de investigar outras possibilidades.
O Simulador do MPLAB X inicia, mas a execução parece não avançar. O sintoma normalmente reflete não um congelamento, mas uma simulação muito lenta decorrente de chamadas a __delay_ms(). No programa do contador, por exemplo, cada iteração contém um atraso de 10 ms, o que, em termos de ciclos de clock, corresponde a centenas de milhares de instruções simuladas. A aplicação de Shift+F5 para pausar a execução normalmente revela que o simulador está dentro de uma dessas chamadas de delay. A prática recomendada é colocar o breakpoint imediatamente após a chamada, evitando que a simulação percorra esses ciclos improdutivos.
O botão B1 (RB0) nunca é detectado no Simulador. O Simulador do MPLAB X inicializa todos os pinos de entrada com valor 0 (nível baixo) por padrão. Isso significa que, do ponto de vista do código, RB0 começa na condição equivalente a “botão pressionado”. Como a lógica do programa detecta transições de 1 para 0, e o estado inicial já é 0, nenhuma borda de descida ocorre. A solução consiste em, antes de iniciar a depuração, abrir a janela SFR, localizar PORTB e forçar o bit 0 em 1 — condição de “botão solto”. A partir desse estado inicial consistente, alterações posteriores para 0 produzirão as bordas de descida esperadas.
O PICSimLab trava ou os componentes não aparecem após o carregamento do PCF. Verifique antes de mais nada a versão do PICSimLab instalada — o arquivo acepic_pro_v82.pcf que acompanha este apêndice foi gerado para a versão 0.9.1 ou superior, e versões anteriores podem não reconhecer corretamente todos os campos. Se os componentes aparecem mas sua disposição encontra-se confusa ou sobreposta, o comando Board → Reset Position reposiciona os elementos segundo o arranjo original.
Os atrasos no programa parecem incorretos na simulação. No Simulador do MPLAB X, a frequência de clock precisa estar definida em 48 MHz no campo Project Properties → Simulator → Clock Frequency. No PICSimLab, o equivalente é a configuração Board → Clock igual a 48 MHz. A ausência de uma dessas configurações leva as macros __delay_ms() e __delay_us() a produzirem atrasos com escala incorreta, pois elas calculam o número de ciclos a consumir com base na frequência informada ao compilador.
Considerações Finais
Ao dominar a operação combinada do PICSimLab e do Simulador embutido do MPLAB X, você conquista uma capacidade investigativa que se prolongará por todo o semestre e por toda a sua atividade futura em sistemas embarcados. Os programas que envolvem leitura do conversor A/D, controle por PWM, comunicação serial, uso de interrupções e outros recursos avançados do PIC18F4550 — conteúdos que você abordará nos módulos subsequentes — beneficiam-se diretamente dessa combinação de ferramentas, cada qual atuando no domínio em que é mais eficaz. O depurador e o simulador de hardware, operados em articulação, constituem o recurso analítico mais completo disponível a você antes que o código seja efetivamente gravado na placa física, e a facilidade de uso que essa articulação proporciona não deve ser subestimada: o custo de um erro detectado em simulação é sempre menor do que o custo do mesmo erro detectado após a gravação no hardware.