A ds by V iew P assw ord A d O ptions

Compartilhar 0 mais Próximo blog» Criar um blog Login

Escola Parobé - Microprocessadores PIC

Blog destinado ao apoio no estudo do microcontrolador PIC 18F4550

QUARTA-FEIRA, 21 DE AGOSTO DE 2013 ARQUIVO DO BLOG

▼ 2013 (11)
ÍNDICE ▼ Agosto (1)
ÍNDICE

Novidades: ► Junho (3)

Máquina de Lavar - Material de Apoio ► Maio (3)

PWM - Material de Apoio ► Abril (1)

================================================================ ► Março (3)

=====

MICROCONTROLADORES & PIC QUEM SOU EU

Pilger
Ambiente de desenvolvimento Visualizar meu
perfil completo
Material de apoio

Códigos de exemplo

Placa de desenvolvimento

Bootloader - carregando os programas via USB

Compilando arquivos para carregar via USB usando o Bootloader

Gravador - Implementação para não depender do bootloader

Problemas de simulação no proteus

Lógica de programação e comandos de linguagem C

Postado por Pilger às 16:16 Nenhum comentário:
+1 Recomende isto no Google

TERÇA-FEIRA, 18 DE JUNHO DE 2013

Lógica de programação e comandos de linguagem C

Post destinado a explicação de lógica de programação e comandos de linguagem C

================================================================
======
Condições ou Expressões Lógicas
A condição na linguagem C é definida como uma expressão que pode
ser verdadeira ou falsa.
À este tipo de expressão dá-se o nome de expressão lógica.
Por exemplo, (3 > 2) é uma expressão lógica que possui valor verdadeiro. Por outro
lado, (4 < 1) é uma expressão lógica que possui valor falso.
Os operadores (< e >) usados nos exemplos acima são chamados de operadores
relacionais pois possibilitam saber qual a relação existente entre seus dois operandos.
Além destes dois existem mais 4 operadores relacionais, que podem ser vistos na
tabela seguir:

Operadores Relacionais
== Igual a

!= Diferente

>= Maior ou igual

> Maior que

< Menor que

<= Maior ou igual

Além dos operadores relacionais, existem os chamados operadores

lógicos ou "conectivos lógicos". Estes, servem para conectar duas expressões
relacionais. Os operadores lógicos da linguagem C são apresentados na tabela a seguir:

Operadores Lógicos

|| OU lógico

&& E lógico

! Negação

Estes operadores OU e E devem ser sempre usados entre duas expressões

relacionais, como por exemplo:

((2 > 1) || (3 < 7)) : resultado VERDADEIRO

((3 < 2) && (2 == 2)) : resultado FALSO
((5 !=0) || (1 < 2)) : resultado VERDADEIRO

O operador de Negação deve ser usado antes de uma expressão relacional, como
por exemplo:

!(2 > 1): resultado VERDADEIRO

!(1 < 0): resultado FALSO

Precedência de Operadores
! Operador de negação Executado
Antes
- menos unário (sinal)

*/% Operadores Multiplicativos

+- Operadores aditivos

< > <= >= == != Relacionais

&& AND lógico Executado

Depois
|| OR lógico

Comando IF
O comando IF serve para alterar o fluxo de execução de um programa em C
baseado no valor, verdadeiro ou falso, de uma expressão lógica.
Formato 1:

if (expr_log)
comando1; // executado se "expr_log" for verdadeira
comando2; // executado sempre independente da condição

Formato 2:

if (expr_log)
comando1; // executado se "expr_log" for verdadeira
else comando2; // executado se "expr_log" for falsa
comando3; // executado sempre, independente
 // do resultado do teste

Comando IF com BLOCOS

Formato 3:

if (expr_log)
{
comando1; // executados se "expr_log" for verdadeira
comando2;
comando3;
}
else
{
comando4; // executado se "expr_log" for falsa
comando5;
comando6;
}
comando7; // executado sempre independente da condição
comando8; // executado sempre independente da condição

Aninhamento de Ifs
Exemplo 1: sem blocos e sem ELSE

if (expr_log)
if (expr_log2)
comando2; // executado se "expr_log" e
// "expr_log2" forem AMBAS verdadeiras
comando3; // executado sempre

Exemplo 2: sem blocos, o ELSE é sempre do IF anterior

if (expr_log)
if (expr_log2)
comando2; // executado se "expr_log" e
// "expr_log2" forem AMBAS verdadeiras
else comando3; // executado se "expr_log" for VERD
// e se "expr_log2" for FALSA
comando4; // executado sempre

Exemplo 3: O ELSE é sempre do IF anterior dentro do BLOCO

if (expr_log)
{
if (expr_log2)
comando2;
}
else comando3; // executado se "expr_log" for FALSO
// pertence ao primeiro IF
comando4; // executado sempre

Exemplo 4:

if (expr_log)
{
comando1; // executado se expr_log for VERDADEIRA
comando11;
if (expr_log2)
{
comando2; // executado se expr_log e expr_log2
comando21; // forem ambas VERDADEIRAS
}
else
{
comando3; // executado se expr_log for VERDADEIRA
comando31; // e expr_log2 for FALSA
}
comando4; // executado se expr_log for VERDADEIRA
}
else
{
comando5; // executado se expr_log for FALSA
comando51;
if (expr_log3)
 {
comando6; // executado se expr_log for FALSA
comando61; // e expr_log3 for VERDADEIRA
}
else
{
comando7; // executado se expr_log for FALSA
comando71; // e expr_log3 for FALSA
}
comando8; // executado sempre que expr_log for FALSA
}
comando9; // executado sempre

Comando SWITCH
int op;

printf("Digite a sua opção\n");

scanf ("%d",&op);
switch (op)
{

case VALOR1:
comando1; // executa estes comandos se
comando11; // op for igual a VALOR1
comando111;
break;
case VALOR2:
comando2; // executa estes comandos se
comando22; // op for igual a VALOR2
comando222;
break;
default:
comando3; // executa estes comandos se
comando33; // op for diferente de VALOR1 e
comando333; // de VALOR2

Observações

O parâmetro do switch deve ser int ou char

O valor após o case dever ser uma CONSTANTE
Muito Cuidado: A falta do break faz o controle passar ao
próximo case

Atribuição Condicional
a = (a>5)? 10 : 50;
Este comando é equivalente a

if(a>5)
a = 10;
else a = 50;
Postado por Pilger às 15:47 Nenhum comentário:
Recomende isto no Google

SEGUNDA-FEIRA, 17 DE JUNHO DE 2013

Problemas de simulação no proteus

Para transferir o programa utilizando o bootloader/PICDEM é necessário realizar as

modificações para que o programa inicie no endereço 0x800. ( Compilando arquivos
para carregar via - USB )

Para simulação por software, é necessário "desfazer as modificações" e recompilar o

software novamente.

Outra item importante a ser observado são as diferenças de compilação:

Build: Compila o programa

Clean and Build: Compila e limpa arquivos intermediários durante a
compilação.
Postado por Pilger às 06:34 Nenhum comentário:
Recomende isto no Google

QUARTA-FEIRA, 5 DE JUNHO DE 2013

Gravador - Implementação para não depender do bootloader

Gavador para qualquer modelo de PIC

usbpicprog-gravador-programador-microcontrolador-microchip-pic-usb-
profissional-opensource
Open Programmer
Open Programmer – Programador Open Source USB para Microntroladores
PIC, EEPROMS Microware, Microntroladores ATMEL, dispositivos I2C/SPI e
outros Leia mais: http://www.te1.com.br/2012/10/programador-open-source-usb-
para-microntroladores-pic-eeproms-microware-microntroladores-atmel
Open Programmer Beta
Postado por Pilger às 03:14 Nenhum comentário:
Recomende isto no Google

SEGUNDA-FEIRA, 20 DE MAIO DE 2013

Compilando arquivos para carregar via USB usando o Bootloader

O bootloader carregado no pic ocupa a área da memória flash compreendida entre

0x000 e 0x7FF.

Por padrão temos:

o vetor de reset no endereço 0x000
os vetores de interrupção alta e baixa nos respectivos endereços 0x008 e
0x018
Para não sobrescrever o bootloader durante a gravação é necessário indicar um
deslocamento de 0x800 nestes endereços, com isso teremos:
o vetor de reset no endereço 0x800
os vetores de interrupção alta e baixa nos respectivos endereços 0x808 e
0x818
1. MODIFICAÇÕES NO MPLABX
Obs.: essas modificações estão associadas ao projeto, então para cada projeto é
necessário efetuar novamente essas configurações.
Clique no menu Run\Set Project Configuration\Customize...
 XC8 linker
Options categories: Runtime
Marque a caixa de seleção (que está desmarcada) "Format hex file for
download".
Controla condicionado do arquivo HEX Intel para uso com bootloaders.

Additional Options, insira o código --output=default,+inhx032

Clique em Ok para assumir as modificações

Options categories: Additional Options

Codeoffset = 800
Indique o valor da posição de início do código, digite 800

Clique Ok para validar as mudanças

Compile o projeto
Observações importantes:
 1. Estas opções são utilizadas para gerar um arquivo HEX para ser usado na
implementação do hardware físico.
2. Para simulação: o arquivo gerado não serve para simulação. É necessário
desfazer as aletrações para obter um arquivo HEX que pode ser utilizado em
simulação.

2. PROVA DE "SÃO TOMÉ: VER PARA CRER QUE AS MODIFICAÇÕES FORAM REALIZADAS

2.1 Visualizando as modificações no vetores e ponto de início (arquivo

.map)
Na pasta "projeto"\dist\default\production

Abra o arquivo com extensão MAP em um editor de texto (bloco de notas)

Você verá os endereços após o remapeamento

2.2. Modificações de correção do arquivo HEX

Na pasta "projeto"\dist\default\production

Abra o arquivo HEX usando um editor (bloco de notas por exemplo)

Na primeira linha deve conter o código :020000040000FA

O arquivo HEX está pronto para ser transferido utilizando a comunicação USB através
do bootloader.
Postado por Pilger às 16:14 Nenhum comentário:
Recomende isto no Google

SEXTA-FEIRA, 17 DE MAIO DE 2013

Bootloader - carregando os programas via USB

Obs.: O desenvolvimento deste post praticamente igual (com alguns ajustes) ao

site http://www.hpspin.com.br/uol/bootloader/
Agradecimentos ao ex-aluno Mirayr Raul que ajudou no dismitificar o funcionamento do
bootloader.
USB E BOOTLOADER
Alguns microcontroladores da família 18F como o PIC18F4550 possuem porta de
comunicação USB para facilitar a comunincação entre o PC e o microcontrolador. Uma
das opções é usar a porta USB para gravar o programa no microcontrolador usando um
bootloader, programa que fica residente no próprio microcontrolador e permite que o
programa de aplicação seja gravado sem a necessidade de um programador.
A Microchip fornece um framework com vários exemplos que permitem desenvolver
aplicações em seus microcontroladores usando a porta USB. Nesta experiência,
usaremos somente alguns arquivos mas, quem quiser, poderá baixar todo o diretório
contendo o framework em USB Framework for PIC18, PIC24 & PIC32 e baixe o arquivo
clicando no link "Microchip Application Libraries Download Page.
Obs.: Para quem já está trabalhando com o MPLABX e o compilador XC8, baixe os
arquivos sugeridos mais abaixo.

O QUE É O BOOTLOADER
O bootloader é um programa que será gravado no microcontrolador, uma única vez, por
um programador comum, como um McFlash, um JDM ou através do ICSP. A partir daí, o
programador não será mais necessário, pois bastará conectar o microcontrolador na
porta USB e transferir o programa de aplicação para o microcontrolador quantas vezes
forem necessárias, sem que seja necessário remover o chip do circuito e numa
velocidade muito mais alta do que a velocidade alcançada pelos programadores
comuns.

HARDWARE NECESSÁRIO
A placa de desenvolvimento já oferece o básico do que é apresentado abaixo,
com exceção dos leds em RD0 e RD1, que servem para indicar o estado da gravação.
A figura abaixo mostra uma sugestão do esquema elétrico do circuito necessário para
esta gravação (este circuito está incluído na placa de desenvolvimento):

INSTALAÇÃO DOS PROGRAMAS NECESSÁRIOS

Baixe os arquivos a disposição:

Arquivo HEX do bootloader

Programa para transferência de arquivos via USB usando o bootloader
Arquivo HEX de um teste de led piscante em RA2
Exemplo completo com fonte para C18 de led piscante em RD3
Exemplo completo com fonte para C18 de led (RD3) controlado por chave
em (RB4)
Obs.: Os exemplos acima foram testados

Siga o roteiro abaixo:

1. Instale o programa MCHPFSUSB_Setup_v1.3. Ele será instalado por padrão em

C:\MCHPFSUSB
2. Faça um atalho na área de trabalho para o programa PDFSUSB.exe
(C:\MCHPFSUSB\Pc\Pdfusb\PDFUSB.exe). Esse programa será usado para
gravar aplicações (arquivos .hex) no microcontrolador através da posta USB.
3. Usando o seu programador de PIC favorito, abra o arquivo USB Device -
 MCHPUSB - MCHPUSB Bootloader - C18 - PICDEM FSUSB.hex e grave-o no
microcontrolador. Ele será gravado somente desta vez e ficará residente no chip
para receber suas aplicações pela porta USB. (Para a construção de gravadores
existe os links no post anterior).
4. Conecte o cabo USB no PC. A princípio nada vai acontecer. Pressione o
botão BOOT, que esta ligado ao PORTB<4> (pino37) do PIC e, em seguida,
pressione e solte o botão RESET. Quando os dois LEDs começarem a piscar
alternadamente, solte o botão BOOT e o bootloader estará pronto para receber
programas pela porta USB. Na primeira vez que esse procedimento for realizado,
o sistema operacional vai dizer que um novo hardware foi detectado e é
necessário instalar um driver para o dispositivo USB. Dirija o instalador para o
diretório C:\MCHPFSUSB\Pc\MCHPUSB Driver\Release e, se tudo correr bem, no
Windows nunca se sabe, o driver será instalado. Você pode verificar no
gerenciador de dispositivos do Windows

GRAVANDO PROGRAMAS NO MICROCONTROLADOR

Conecte o cabo USB do circuito no PC. Pressione o botão BOOT, que esta ligado ao
PORTB<4> (pino37) do PIC e, em seguida, pressione e solte o botão RESET. Quando
os dois LEDs começarem a piscar alternadamente, solte o botão BOOT e o bootloader
estará pronto para receber programas pela porta USB. Para gravar o programa, use a
aplicação PDFSUSB.exe seguindo os passos abaixo:

1) Execute o programa PDFSUSB.exe e na janela dessa aplicação, clique o botão Load

HEX File para abrir a janela de seleção de arquivos.

2) Escolha o programa que deseja gravar no microcontrolador. O programa deve ter a

extenção .hex.

3) Na janela de configuração que aparecer, escolha a opção Não. Essa opção deve ser
sempre selecionada pois ela não permitirá que os bits de configuração sejam
regravados pelo seu programa. Se a opção Sim for escolhida, o bootloader vai deixar de
funcionar e não será possível, da próxima vez, gravar o programa via bootloader. Nesse
caso, o bootloader deverá ser regravado com um programador de porta serial ou outro
qualquer.
4) O programa em formato hexa decimal será carregado e mostrado na parte inferior da
janela.

5) Abra a lista Select PICDEM FS USB Board e selecione o dispositivo ativo na porta
USB, relativo ao circuito que iremos gravar, indicado pela seta 1.

6) Após selecionar o dispositivo USB, clique no botão Program Device, indicado pela
seta 2 para iniciar a gravação do programa. Quem esta acostumado a usar
programadores de porta serial vai notar que, com o bootloader, o programa é transferido
para o microcontrolador a uma velocidade muito alta.

7) Quando a gravação terminar, confira as mensagens que aparecem na janela de

mensagens, indicado pela seta 1. Se tudo correu bem, então pode iniciar a execução do
programa no microcontrolador, clicando no botão Execute, indicado pela seta 2. Não
será necessário desconectar o circuito da porta USB. Pode-se, também, iniciar o
programa pressinonando-se o botão RESET do circuito.
Observação importante: O arquivo HEX deve ser compilado para iniciar em 0x800, em
breve será publicado um tutorial

Fontes de consulta sobre o assunto:

http://www.hpspin.com.br/uol/bootloader/
http://microcontrollershop.com/product_info.php?products_id=2125
http://robotica.estg.ipleiria.pt/clube/index.php/projetos-tutoriais/55-
programacao-de-um-pic-por-usb-sem-programador
http://picprojects.org.uk/projects/picprojects.htm
Postado por Pilger às 11:30 Nenhum comentário:
Recomende isto no Google

QUARTA-FEIRA, 1 DE MAIO DE 2013

Placa de desenvolvimento

PLACA PARA DESENVOLVIMENTO:

O esquema é a estrutura básica para o desenvolvimento de aplicações.

A circuito foi pensado para a montagem de circuitos periféricos em uma protoboard
Arquivos de esquema elétrico
Versão 3 - Correção da posição dos Leds bootloader do port E para o port D
Circuito em PDF
Circuito em DSN

Itens do esquema elétrico:

Fonte externa maior do que 5V
Cabo USB para comunicação
Display lcd 2x16
Placa desenvolvimento com:
Cristal de 20MHz e 2 capacitores de 15pF
Capacitor VUSB - 470nF
Conector Port A
Conector Port B
Conector Port C
Conector Port D
Conector Port E
Conector LCD
Conector para alimentação de circuito externo
 Jumper para alternar entre alimentação externa e USB
Jumper para alternar botão bootloader e Port externo RB4
Jumper para alternar entre Led 1 bootloader e Port externo RE0
Jumper para alternar entre Led 2 bootloader e Port externo RE1
Botão Reset
Botão bootloader
Leds 1 e 2 para indicar ação do bootloader
Leds para indicar +5V da fonte externa, USB e alimentação
circuito
Pinagem USB

Foto do atual macarrão de fios na placa protótipo.

Fotos de frente e verso da placa do aluno Everton Leonel, o primeiro a concluir a placa.
Belo trabalho.
Alguns exemplos de placas desenvolvidas pelos alunos
 A ds by V iew P assw ord A d O ptions

Postado por Pilger às 16:43 Nenhum comentário:

Recomende isto no Google

Início Postagens mais antigas

Assinar: Postagens (Atom)

Modelo Picture Window. Imagens de modelo por Dizzo. Tecnologia do Blogger.

A ds by V iew P assw ord A d O ptions