Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila de Programação de PICs em C e Proteus PDF
Apostila de Programação de PICs em C e Proteus PDF
br
Introdução à programação
PIC de microcontroladores –
www.pictronics.com.br
Conteúdo
Programas utilizados:
• MPLAB – www.microchip.com
• PICC-CCS Lite – www.ccsinfo.com
• Proteus v7.7 – www.labcenter.co.uk
Introdução:
Por exemplo, para se fazer uma simples circuito de controle de um elevador seriam
necessários um microprocessador, memória ROM para o programa, memoria RAM para
os dados, de uma porta paralela para dar saída aos acionamentos, de uma outra porta pra
receber os sinais digitais dos sensores, de uma porta serial para fazermos as
configurações e rodarmos os diagnósticos, de um conversor AD para ler o sensor de
carga que informa o peso total das pessoas que entram no elevador, de um temporizador
para medir o tempo que a porta deve ficar aberta, dentre outros. Com essa extensa lista,
chegamos a um circuito cujo diagrama de blocos é mostrado na Figura 1.
Introdução à programação de microcontroladores – www.pictronics.com.br
Afora isso, como não será feito processamento sofisticado, sua CPU não precisa ter uma
grande capacidade de processamento, mas deve oferecer um conjunto de instruções
simples, que gere programas pequenos e de rápida execução, ou seja, as instruções
devem ser pequenas e velozes. É preciso ainda oferecer uma forma simples de se
interfacear com outros periféricos que venham a ser adicionados.
Levando em conta tudo que foi dito, chegamos ao diagrama em blocos da figura 2, onde
se apresenta a típica arquitetura de um microcontrolador. É claro que, de acordo com a
finalidade do microcontrolador, é possível integrar mais recursos e tal possibilidade foi
representada pelos blocos rotulados com "etc".
Introdução à programação de microcontroladores – www.pictronics.com.br
RISC e CISC
Na sua essência, uma máquina RISC oferece um número muito reduzido de instruções,
desde uma a poucas dezenas, e cada instrução apenas realiza uma ação muito simples.
Se este conjunto satisfizer o critério de ser genérico, isto é, permitir programar qualquer
algoritmo, então temos de reconhecer a grande vantagem desta abordagem: a sua
simplicidade facilita a construção hardware da arquitetura do microcomtrolador.
Nomeadamente, a Unidade de Controle da CPU fica mais simples e, portanto, menor,
onde ocupa menor área na pastilha ('chip') do material semicondutor (Silício,
habitualmente) sobre o qual são implantados os circuitos digitais que realizam os
componentes do controlador. Ficando a Unidade de Controle menor, mais espaço livre
fica na CPU, que pode ser aproveitado para outras unidades que aumentem o ritmo de
execuções do CPU, por exemplo, um maior número de registadores de dados, uma
memória interna ao CPU, etc.
Uma máquina CISC segue uma filosofia oposta, procurando suportar o mais
diretamente possível os mecanismos das instruções da linguagem de alto nível. A sua
principal desvantagem é que a Unidade de Controle fica mais complexa, dada a
variedade e complexidade das instruções. Para além do mencionado aspecto de
aumentar o espaço ocupado pelos circuitos, isto também dificulta as otimizações das
micro-ações que a Unidade de Controle deve realizar, para obter execuções mais rápidas
das instruções. Por exemplo, no modelo CISC, dada a grande variedade de instruções,
estas têm formatos variáveis e as suas representações em bits variam, por exemplo,
desde 1 até 6 bytes, equivalente aos seus tipos.
Observações importantes:
entradas analógicas, memória ROM, memória RAM, etc...), mas todos podem ser
programados com a mesma linguagem.
Modelos da família 18 são mais rápidos e um pouco mais caros, continuando a ser de 8
bits.
Modelos da família 24 são de 16 bits, e indicados para aplicações que exijam mais
poder de processamento.
Os microcontroladores PIC são indicados para aplicações mais simples, que não
necessitem de grande volume de dados manipulados, e que não necessitem
processamento em tempo real de alto desempenho.
Requisitos de Hardware
Introdução à programação de microcontroladores – www.pictronics.com.br
Introdução à programação de microcontroladores – www.pictronics.com.br
Opcionais:
Introdução à programação
Fluxograma:
Variáveis de dados
Modificadores de tipo
Além dos tipos de dados vistos, podemos utilizar comandos especiais da linguagem C
para modificar os tipos básicos, de forma a obter outros tipos de dados.
Esses comandos especiais são chamados de modificadores de tipo e são os seguintes:
signed, unsigned, short e long.
O modificador signed pode ser utilizado para modificar um tipo base de dados de forma
que ele possa representar tanto números positivos quanto negativos.
Note que devido ao fato de utilizar um bit para representação do sinal, a magnitude
absoluta da representação do tipo modificado será metade da magnitude do tipo não
modificado.
Assim, um tipo de dados signed int pode representar valores de -128 a +127 em vez de
0 a 255.
O modificador unsigned define um tipo de dado sem sinal, o que é o padrão do
compilador da CCS. Note que o padrão ANSI especifica que os tipos padrão de dados
da linguagem C é signed.
Já o modificador short é utilizado para definir uma variável de tamanho menor que o do
tipo modificado, ou seja, uma versão reduzida do tipo especificado. Assim, se
especificarmos uma variável como sendo do tipo short int, ela será uma versão
reduzida de int, o que no caso do compilador CCS cria uma variável de apenas 1 bit de
tamanho (o que é chamado de flag ou sinalizador).
Finalmente, temos o modificador long, utilizado para ampliar a magnitude da
representação do tipo especificado. Desta forma, um tipo de dado long int terá um
tamanho de 16 bits, ou seja, irá ocupar duas posições de memória RAM do PIC e terá
magnitude de 0 a 65535.
A seguir, temos uma tabela com todos os tipos de dados disponíveis por padrão no
compilador CCS:
Introdução à programação de microcontroladores – www.pictronics.com.br
Operadores
Atribuição
x = 10;
y = x;
Repare que a atribuição e sempre avaliada da direita para a esquerda é não e possível
realizar uma atribuição no sentido inverso.
Introdução à programação de microcontroladores – www.pictronics.com.br
Aritméticos
Operador Ação
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto de divisão inteira
++ Incremento
-- Decremento
Tabela de operadores
variavel++; ou variavel--;
Vejamos um exemplo:
int x, y, z;
x = 0;
y = x ++;
z = ++ x;
Neste caso, após a execução dos três comandos, o valor da variável “x” será igual a 2, o
valor da variável “y” será igual a 0 e o valor da variável z será igual a 2.
Note que ha uma diferença clara entre escrever "y = x + 1" e "y = ++x":
Relacionais
São utilizados em testes condicionais para determinar a relação existente entre os dados:
Operador Ação
> Maior que
>= Maior ou igual a
< Menor que
<= Menor ou igual a
== Igual a
!= Diferente de
Não ha muito que falar sobre estes operadores, já que o seu funcionamento e idêntico ao
que todos estudamos na disciplina de matemática e que utilizamos no nosso dia-a-dia.
Lógicos Booleanos
Operador Ação
&& AND (E)
|| OR (OU)
! NOT (NAO)
Vejamos um exemplo:
int x, y;
x = 10;
if (x > 5 && x < 20) y = x;
Como podemos verificar a variável "y" somente será igual ao valor da variável "x" se o
valor de "x" for maior que 5 e "x" for menor que 20. O que nos leva a concluir que ao
final da execução do programa "y" será igual a 10.
Os operadores 1ogicos bit a bit são utilizados para realizar operações logicas entre
elementos ou variáveis. No entanto, ao contrario dos operadores lógicos simples, os
operadores lógicos bit a bit podem resultar em um valor da mesma magnitude dos
elementos operados.
Operador Ação
& AND (E)
| OR (OU)
^ XOR (OU exclusivo)
~ NOT (complemento de um)
>> Deslocamento a direita
<< Deslocamento a esquerda
Outros Operadores
Além dos operadores anteriormente citados, podemos encontrar ainda outros operadores
não tão conhecidos em C:
Operador Ação
? Operador ternário condicional
, Separador de expressões
. Separador de estruturas
-> Ponteiro de elemento de estrutura
(tipo) Operador de Modelagem de dado
sizeof Retorna o tamanho da variável
Exemplos:
int liga_led(void)
{
output_high (pin_a0); // ativação do pino 0 da porta A
}
int desliga_led(void)
{
output_low (pin_a0); // deslisa o pino 0 da porta A
}
main()
{
while (true)
(input (pin_b0) == 1) ? liga_led() : desliga led();
}
Associação de operadores
Para facilitar a vida do programador, a linguagem C inclui ainda outra característica que
é a abreviação de operadores em atribuições e funciona da seguinte forma:
Forma Forma
reduzida expandida
x += y x=x+y
x -= y x=x-y
x *= y x=x*y
Ordem Operador
Maior ( ) [ ] ->
! ~ ++ -- .
(tipo) * & sizeof
* / %
+ -
<< >>
<<= >>=
== !=
&
^
|
&&
||
?
= += -= *= /=
Menor ,
Introdução à programação de microcontroladores – www.pictronics.com.br
Declarações de controle
Comando if
if (condição)
comandoA;
{ else comandoB; }
Outra forma:
if (condição)
{
comandoA1;
comandoA2;
...
} else
{
comandoB1;
comandoB2;
...
}
Exemplo de código:
#include <p16f877.h>
#use delay(clock=4000000)
#fuses INTRC, NOWDT, PUT, NOMCLR, NOLVP, NOBROWNOUT
int x;
main()
{
while (true)
{
x = input_a();
output_b (0);
if (x==0) output_high (pin_b0); else
if (x==1) output_high (pin_b1); else
if (x==2) output_high (pin_b2); else
if (x==4) output_high (pin_b3); else
output_high (pin_b4);
}
}
Introdução à programação de microcontroladores – www.pictronics.com.br
Comando Switch
switch (variável)
{
case constante1:
comandoA;
...
break;
case constante2:
comandoB;
...
break;
...
...
default: // a diretiva default pode ou não estar presente
comandoZ;
...
}
Exemplo de código:
#include <16f877.h>
#use delay(clock=4000000)
#fuses HS, NOWDT, PUT, NOBROWNOUT, NOLVP
main()
{
while (true)
{
output port_b(0);
switch (input_a())
{
case 0:
output_high (pin_b0);
break;
case 1:
output_high (pin_b1);
break;
case 2:
output_high (pin_b2);
break;
case 3:
output_high (pin_b3);
Introdução à programação de microcontroladores – www.pictronics.com.br
break;
default:
output_high (pin_b4);
}
}
}
Laço For
O laço for é uma das mais comuns estruturas de repetição, sendo a versão c considerada
uma das mais poderosas e flexíveis dentre todas as linguagens de programação.
O laço for é dado por:
ou,
Cada uma das três seções do comando for possui uma função distinta, conforme se
segue:
Inicialização: esta seção conterá uma expressão válida utilizada malmente para
inicialização da variável de controle do laço for
Condição: esta seção pode conter a condição a ser avaliada Para decidir pela
continuidade ou não do laço de repetição. Enquanto a condição for avaliada como
verdadeira, o laço for permanecera em execução.
Incremento: esta seção pode conter uma ou mais declarações para incremento da
variável de controle do laço.
Exemplo de código:
#include <16F628.h>
#fuses INTRC_IO, NOWDT, PUT, NOBROWNOUT, NOMCLR, NOLVP
#use delay(clock=4000000)
#use rs232(baud=19200,parity=N,xmit=PIN_B2,rcv=PIN_ B1,bits=8)
main()
{
int conta;
for (conta=0; conta<=10; conta++) printf (“%u\r\n”, conta);
}
Introdução à programação de microcontroladores – www.pictronics.com.br
Laço While
Outro tipo de laço disponível na linguagem é o comando while e que possui a seguinte
forma geral:
ou ainda:
while (condição)
{
comandol;
comando2;
…
}
Também e possível utilizar as clausulas break e continue com o comando while e for.
Elas possuem a mesma função para os comandos while e for.
Exemplo de código
#include <16F628.h>
#use delay(clock=4000000)
#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP
#use rs232(baud=19200,parity=N,xmit=PIN_B2,rcv=PIN_B1)
main()
{
Laço Do-While
O comando do e utilizado juntamente com o comando while para criar uma estrutura de
repetição com funcionamento ligeiramente diferente do while e for tradicionais.
De fato, a diferença entre a estrutura while tradicional e a estrutura do-while é que esta
ultima realiza a avaliação da condição de teste no final de cada ciclo de iteração do laço
de repetição, ao contrario do que já estudamos sobre o while, o qual realiza o teste no
inicio de cada ciclo.
ou,
do
{
comandoA;
comandoB;
...
} while (condição);
Função Printf
Assim, a função printf é uma excelente forma de transmitir dados serialmente do PIC
para outro dispositivo externo, como, por exemplo, um terminal de vídeo ou um
microcomputador.
printf ( argumento(s) );
Introdução à programação de microcontroladores – www.pictronics.com.br
Código Caractere
YYY Constante Octal yyy
\xyyy Constante hexadecimal yyy
\0 Nulo (null)
\a Campainha (BEL)
\b Retrocesso (backspace)
\t Tabulação horizontal
\n Linha nova (line feed)
\v Tabulação vertical
\f Avanço de formulário
\r Retorno de carro (Return)
\” Aspas
\’ Apóstrofo
\\ Barra invertida “\”
Configuração do PIC
Fuses são diretivas para configuração inicial de diversos parâmetros de um PIC, essas
configurações variam de PIC para PIC e devem ser consultadas no Datasheet de cada
PIC para correta configuração, também temos a descrição da configuração dos Fuses na
referência de linguagem do compilador PICC em inglês.
Diretivas #use
#use delay
Esta diretiva é necessária para a utilização das funções de atraso de tempo (delay_ms ou
delay_us) e também para as rotinas de comunicação serial.
Introdução à programação de microcontroladores – www.pictronics.com.br
#use satandard_io
#use fast_io
Neste modo o compilador não irá inserir nenhuma instrução para controle dos
registradores TRIS do dispositivo, produzindo um código mais rápido e eficiente,
porém, devemos alterar o registrador TRIS pelo comando set_tris (x) no início do
programa.
#use fixed_io
No modo fixo o compilador irá inserir código de configuração dos registradores TRIS a
cada utilização dos pinos especificados. Note que o registrador TRIS é programado com
a configuração selecionada na diretiva e não pelo tipo de função executado.
#use i2c
Exemplo:
#use i2c(Master,Slow,sda=PIN_C4,scl=PIN_C3)
Introdução à programação de microcontroladores – www.pictronics.com.br
Opção Descrição
MASTER Seta o modo mestre
SLAVE Seta o modo escravo
SCL = pino Especifica qual o pino de clock I2C
SDA = pino Especifica qual o pino de dados I2C
ADDRESS = nn Especifica o endereço do dispositivo em modo escravo
FAST Utiliza a especificação de alta velocidade I2C
SLOW Utiliza a especificação de baixa velocidade I2C
RESTART_WDT Reinicia o watchdog enquanto aguarda dados na função
I2C_READ
FORCE_HW Força a utilização do hardware interno (SSP ou MSSP) do PIC
#use rs232
Opções Descrição
BAUD = valor Especifica a velocidade de comunicação serial.
XMIT = pino Especifica o pino de transmissão de dados.
RCV = pino Especifica o pino de recepção de dados.
RESTART_WDT Determina qual a função getc() reset o watchdog enquanto
aguarda a chegada de um caractere.
INVERT Inverte a polaridade dos pinos de TX/RX. Não pode ser
utilizada com o hardware interno.
PARITY = x Seleciona a paridade (x pode ser: N (sem paridade), E
(paridade par) ou O (paridade ímpar)).
BITS = x Seleciona o número de bits de dados (5 a 9 para o modo
por software e, 8 e 9 para o modo hardware).
FLOAT_HIGH A saída não vai a nível lógico 1. Utilizado com saídas em
coletor aberto.
ERRORS Solicita ao compilador que armazene os erros de recepção
na variável RS232_ERRORS, resetando os flags de erro
quando eles ocorrerem.
BRGH10K Permite a utilização das velocidades disponíveis com o bit
BRGH em 1 em chips que tenham bugs nesta
configuração do hardware.
ENABLE = pino Especifica um pino para atuar como saída de habilitação
durante uma transmissão. Utilizado no protocolo RS485.
STREAM = identificador Associa a interface RS232 a um identificador de stream de
dados. Os streams de dados são utilizados em algumas
funções internas do compilador.
Introdução à programação de microcontroladores – www.pictronics.com.br
Output_low()
Exemplo:
Output_high()
Exemplo:
Output_X()
Exemplo:
Output_B (0x25); // Escreve o valor 0x25 no port B
Output_toggle()
Exemplo:
Output_toggle (pin_b4); // Inverte o nível lógico do pino pin_b4
Input()
Exemplo:
shot int x;
x = input (pin_a0); // Lê o estado do pino A0
Input_X()
Exemplo:
int x;
x = input_b(); // Lê o estado da porta B
Set_tris_X()
Note que o uso desta diretiva é desnecessária com as diretiva #use standard_io e #use
fixed_io, já que nestes modos de IO o compilador configura automaticamente a
direção dos pinos.
Exemplo:
set_tris_b (0b00001111);
// Configura os pinos B0 a B3 como entradas e B4 a B7 como saídas
Introdução à programação de microcontroladores – www.pictronics.com.br
Exemplos de códigos
/* RS232.h
* Arquivo de Comunicação Serial RS232
*/
#include <16F877A.h>
#device adc=8
#use delay(clock=4000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
char c;
while (true)
{
c = getc();
switch (c)
Introdução à programação de microcontroladores – www.pictronics.com.br
{
case 'a':
printf ("Letra A\n\r");
break;
case 'b':
printf ("Letra B\n\r");
break;
default:
printf ("comando nao existe...\n\r");
break;
}
}
}
// Fim do arquivo
/* Display 7 segmentos
* Arquivo 7seg.h
*/
#include <16F877A.h>
#device adc=8 // Configuração do ADC
// Configura Clock
#use delay(clock=4000000)
// Configura RS232
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
/* Arquivo 7seg.c
* Display de 7 segmentos */
#include "7seg.h"
0b10000111, // 7
0b11111111, // 8
0b11100111};// 9
while (true)
{
output_b(0);
switch (input_a()) // Testa a porta A
{
case 0:
output_b (digito[0]);
//printf ("%u\n\r", digito[0]);
break;
case 1:
output_b (digito[1]);
printf ("%u\n\r", digito[1]);
break;
case 2:
output_b (digito[2]);
printf ("%u\n\r", digito[2]);
break;
case 3:
output_b (digito[3]);
printf ("%u\n\r", digito[3]);
break;
case 4:
output_b (digito[4]);
printf ("%u\n\r", digito[4]);
break;
case 5:
output_b (digito[5]);
printf ("%u\n\r", digito[5]);
break;
case 6:
output_b (digito[6]);
printf ("%u\n\r", digito[6]);
break;
case 7:
output_b (digito[7]);
printf ("%u\n\r", digito[7]);
Introdução à programação de microcontroladores – www.pictronics.com.br
break;
case 8:
output_b (digito[8]);
printf ("%u\n\r", digito[8]);
break;
case 9:
output_b (digito[9]);
printf ("%u\n\r", digito[9]);
break;
case 10:
output_b (digito[0]);
printf ("%u\n\r", digito[0]);
break;
}
}
}
// Fim do arquivo 7seg.c
/* Arquivo mainT0.h
* Trabalhando com Timer 0 e interrupção */
#include <16F877A.h>
#device adc=8
#use delay(clock=20000000)
/* Arquivo mainT0.c
* Trabalhando com Timer0 e interrupção para pisca de 1 segundo */
#include "mainT0.h"
#define led pin_b0
{
conta = 0;
output_toggle (led); // inverte o estado do led
}
}
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
// habilita interrupções
enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);
// Arquivo ADC.h
#include <16F877A.h>
#device adc=10 // ADC em 10bits
#use delay(clock=20000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
// Arquivo ADC.C
// Conversão Analógico Digital
#include "adc.h"
#include "mod_lcd.c" // Biblioteca do LCD deve estar junto do arquivo principal
Introdução à programação de microcontroladores – www.pictronics.com.br
void main()
{
long int valor; // variavel de 16 bits
int32 val32; // variavel de 32 bits
while (true)
{
lcd_escreve ('\f'); // apaga o display
// O escalonamento é realizado da seguinte forma:
// resultado = (5000 * valor lido) / 1023
// Para facilitar os cálculos, somamos um ao
// valor lido:
// resultado = (5000 * (valor + 1)) / 1024
// simplificando:
// resultado = ((valor + 1) * 4) + ((valor + 1) * 113) / 128
// Repare que é necessário converter a segunda parte da
// equação para 32 bits para que o compilador efetue o
// cálculo corretamente
valor = read_adc(); // efetua a conversão A/D
// Se o valor é > 0, soma 1 ao valor lido
if (valor) valor += 1;
val32 = valor * 4 + ((int32)valor * 113) / 128;
// imprime o valor da tensão no display
// 5000 = 5,000 Volts ou 5000 milivolts
printf (lcd_escreve,"Tensao = %lu mV", val32);
// se a tecla enter for pressionada
if (kbhit()) if (getc() == 13)
{
// imprime os resultados na serial
printf ("Tensao = %lu miliVolts\r\n",val32);
printf ("Valor = %lu\r\n",valor);
}
delay_ms (250); // aguarda 250 ms
}
}
// Fim do arquivo ADC.c
Introdução à programação de microcontroladores – www.pictronics.com.br
// Arquivo LCD.h
// Tratamento de LCD alfanumérico
#include <16F877A.h>
#device adc=8
#use delay(clock=20000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
// Arquivo LCD.c
// Tratamento de LCD
// arquivo mod_lcd.c deve estar no mesmo diretório do arquivo principal
#include "LCD.h"
#include "mod_lcd.c"
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
// Função lcd_escreve
//lcd_escreve ("Curso de PIC");
while (true)
{
lcd_pos_xy (1, 2); // Pasiciona cursor no LCD
printf (lcd_escreve, "Conta: %3u.", conta);
if (conta != 100)
conta++;
else
conta = 0;
delay_ms (100);
}
}
Assistente de
novos projetos
Introdução à programação de microcontroladores – www.pictronics.com.br
Inicialmente o assistente pede para salvarmos o projeto. Dica: como o compilador gera
muitos arquivos é interessante que guardemos cada projeto novo em uma pasta
separada, assim certificamos que cada arquivo (.hex) seja facilmente encontrado para
gravação.
Pasta
Nome do
destino
Projeto
Botão Salvar
Guias de
configuração
Nome do Projeto
Selecione o PIC
Frequência de
funcionamento
do PIC
Configuração
dos Fuses
Programa exemplo
Assistente de
Projeto
Introdução à programação de microcontroladores – www.pictronics.com.br
Selecione o
PIC
Salvar na
pasta?
Buscar
compilador
Detalhes do
novo projeto
Se já existir um arquivo
adicione ao projeto, senão,
devemos criar um novo.
Botão compilar
Barra de ferramentas do
gravador
Caixa de comunicação do
gravador mostrando que está
pronto para próxima operação!
Para inserir os
componentes
Introdução à programação de microcontroladores – www.pictronics.com.br
Selecione o
componente, clicando
duas vezes com o
botão esquerdo.
Insira os componentes e
faça as ligações, o
hardware depende do
software!
Introdução à programação de microcontroladores – www.pictronics.com.br
Arquivo
fonte do PIC
Frequência
do PIC
Configuração do
Terminal Serial Virtual
Altere os
elementos como
se fosse real
Bibliografia e referências: