A maior rede de estudos do Brasil

Grátis
32 pág.
apostila uc pic- hands on

Pré-visualização | Página 2 de 6

bytes são nomeados por vogais e são chamados pelo datasheet de PORT, como PORTA, PORTB, PORTC, etc. Os bits são mapeados por números, assim, podemos observar nas Figuras 2 e 3 que o canal A3 (apresentado como RA3) está no pino 2 do 16F628, e no pino 5 do16F876. Como cada PORT é um byte, cada um tem 8 canais. Por exemplo, o PORTA vai de A0 até A7, e este último é identificado pelo programa do usuário como “pin_a7”. O PIC16F628 contém as portas A e B, enquanto o PIC16F876 tem as portas A, B e C. Porém, nem todos os canais endereçáveis em teoria estão disponíveis nos pinos externos.
void main(void){
Função principal de qualquer programa em C. É onde realmente começa o programa que será embarcado. Os comandos mencionados anteriormente são chamados de “diretivas do compilador”, ou seja, são usados pelo compilador mas não serão executados pelo PIC. O compilador utiliza esses comandos para configurar registradores especiais no momento da gravação. Portanto, se você escreveu “#fuses XT”, o registrador responsável por indicar a fonte de relógio será configurado no momento do download, e não na inicialização.
set_tris_a(0b11111111); 
Primeiro comando do programa (para este exemplo). Essa função configura os canais GIPO como entrada ou saída. ‘1’ significa “IN” e ‘0’ “OUT”, o que facilita a memorização pela semelhança: 1->In e 0->Out. O prefixo “0b” indica que o número adiante está representado em binário. Para representar um número em hexadecimal, o prefixo usado é “0x”, portanto essa função pode ser escrita: “set_tris_a (0xff);”. Se um número não tiver nenhum prefixo, este será interpretado pelo compilador como no formato decimal, que é nossa forma natural. Podemos dizer então que essa função também pode ser escrita na forma: “set_tris_a (255);”, que surtirá o mesmo efeito. Convém escrever tal função em binário pela melhor visualização dos canais, que estão dispostos em ordem decrescente. Portanto, se o primeiro pino do 16F628 for usado para acender um LED, deve-se configurar o canal A2 como saída, escrevendo: “set_tris_a (0b11111011);”. Recomenda-se que todos os canais que não serão utilizados sejam configurados como entrada, pois estarão em alta-impedância, admitindo qualquer valor. Quanto mais pinos são configurados como saída, maior é a probabilidade do usuário acidentalmente tocá-los ao manusear o protoboard, e isso pode ocasionar a queima do dispositivo.
while(true){
Equivale a escrever “while(1==1){” ou “while(1){”. Esse é o tal loop infinito, onde o programa permanecerá indefinidamente. É dentro desse while que o programador deve construir a fase de trabalho do uC.
1º EXEMPLO: Hello World!
//-------- Pisca LED --------
#include <16F628A.h> 
#fuses INTRC_IO, NOMCLR
#use delay(clock=4000000) 
#use fast_io(a)
#use fast_io(b)
void main(void){
 short flag=0;
set_tris_a(0b11111110); 
set_tris_b(0xff);
while(true){
	output_bit(pin_a0,flag);
	delay_ms(500);
	flag=!flag;
}
}
//-------- Pisca LED --------
#include <16F876A.h> 
#fuses XT
#use delay(clock=4000000) 
#use fast_io(a)
#use fast_io(b)
#use fast_io(c) 
void main(void){
set_tris_a(0b11111110); 
set_tris_b(0xff);
set_tris_c(0xff);
while(true){
 output_high(pin_a0);
	delay_ms(500);
	output_low(pin_a0);
	delay_ms(500);
}
}
Explanação:
short flag=0; 
Declaração e inicialização da variável de 1 bit chamada “flag”. Também pode ser escrito nas formas: “boolean flag=0;” ou “int1 flag=0;”
output_high(pin_a0); 
Coloca o pino mencionado em nível lógico 1 (5V).
output_low(pin_a0); 
Coloca o pino mencionado em nível lógico 0 (0V).
output_bit(pin_a0, flag); 
Coloca o pino mencionado no nível lógico correspondente ao valor corrente da “flag”.
delay_ms(500); 
O programa literalmente pára durante o valor de tempo informado (em milisegundos). O próprio compilador gera o código responsável por esta ação, através de contadores, os quais se baseiam em “#use delay(clock=4000000)”.
flag=!flag; 
Realiza o “complemento de um” da variável “flag”. O símbolo “!” corresponde à operação lógica NOT.
Os pinos configurados como entrada drenam uma corrente extremamente pequena, na ordem de pico-ampéres, pois são colocados em alta-impedância. Assim, podemos considerá-la desprezível.
Os pinos definidos como saída não podem receber sinal externo (corrente), pois, como já dito anteriormente, isso certamente causará o falecimento do uC. Estes dois dispositivos abordados podem fornecer até 25mA por pino de saída. Portanto, se a carga utilizada drenar mais do que esse valor, deve ser utilizado um driver, como um transistor.
Figura 5 – Exemplo 1: hardware 16F876
Figura 6 – Exemplo 1: hardware 16F628
Compilação do programa:
	Inicialmente abra o compilador PICC (PCWHD), clique no símbolo de “pastas” (primeiro acima), e em seguida “Close All”. Agora, para criar um novo projeto, clique novamente no símbolo de “pastas”, e após isso em “New” -> “Source File”. Escolha o diretório onde ficará salvo este primeiro programa e o nomeie de “exemplo1”. Digite o código de exemplo para o uC escolhido e em seguida compile o programa em “Compile” -> “Compile”, ou através da tecla de atalho “F9”. Neste processo o compilador gera 5 arquivos de saída, porém será utilizado apenas o “exemplo1.hex”, que é o código que será transferido para a memória FLASH do uC.
Gravação do programa:
	Coloque o uC escolhido no protoboard e, antes de colocar os outros componentes (capacitor, etc.), insira apenas os jumpers relativos ao ICSP (In Circuit Serial Programming). Plugue agora o cabo do ICSP no protoboard e no gravador PICKit2, e plugue o cabo USB do gravador no PC. Feito isso, abra o software PICKit2. Se o procedimento dito foi feito corretamente, deve aparecer uma mensagem confirmando a detecção do dispositivo. Se isso não ocorreu, confira se houve alguma falha no dito procedimento (ordem dos jumpers, mau contato, etc.), e então clique em “Tools” -> “Check Communication”. Não se deve continuar a partir deste ponto até que o uC não tenha sido detectado. 
Antes de transferir o código, desabilite a função “Tools” -> “Fast Programming”, pois esse modo está bem mais susceptível a falhas de transferência, além de ser pequena diferença em relação ao modo normal. Para verificar se o código foi transferido corretamente, habilite a função “Programmer” -> “Verify on Write”.
Feito tudo, clique em “File” -> “Import Hex”. Escolha o “exemplo1.hex” que foi gerado na compilação e, depois de importado o arquivo, clique finalmente em “Write” para realizar a transferência do código para o uC. Confirmado o sucesso do download, desconecte o plugue ICSP do protoboard, insira os componentes necessários e energize o circuito. Se tudo deu certo, o LED piscará a cada 1 segundo. 
Os componentes não precisam ser retirados para realizar um novo download. Porém, é recomendado que sempre se inicie a construção de um hardware pelos jumpers do ICSP, pois na ocorrência de uma falha (muito comum) deve-se reduzir o hardware para encontrar o defeito.
Outra maneira de realizar o download é pelo botão no PICKit2 (hardware). Essa função é habilitada em “Programmer” -> “Write on PICkit Button”. Quando tal botão é pressionado, o arquivo .hex que está sendo apontado no campo “Source” do PICKit2 (software) é transferido para o uC (devidamente conectado). O mesmo efeito é obtido pelo botão “Write”, eliminando a necessidade de toda vez importar o arquivo a ser transferido. Para testar essa funcionalidade, habilite-a primeiro, depois, se o campo “Source” estiver apontando para o “exemplo1.hex”, mude o tempo de delay no programa (compilador) para 100ms e o recompile. Vá agora para o PICKit2 (software) e, observando a tela, pressione o botão no PICKit2 (hardware). O programa percebe que houve uma alteração e realiza um “reloading”.
Os exemplos