manual do usuário sistema operacional mcdata do usuário - sistema... · manual do usuário –...

Manual do Usuário

Sistema Operacional McData

1. SISTEMA OPERACIONAL ...................................................................................................... 1

1.1. DEFINIÇÃO........................................................................................................................... 1 1.2. CARACTERÍSTICAS ............................................................................................................... 1

2. COMPILAÇÃO ......................................................................................................................... 2

2.1. DEFINIÇÕES E ARQUIVOS DO COMPILADOR............................................................................. 2 2.2. DIAGRAMA DE BLOCOS DE UMA COMPILAÇÃO .......................................................................... 3 2.3. ARQUIVOS DO USUÁRIO........................................................................................................ 3 2.4. COMPILADOR C18................................................................................................................ 3 2.5. LINKER UTILIZADO ................................................................................................................ 4

3. CRIANDO UM PROJETO NO MPLAB .................................................................................... 5

4. FUNÇÕES .............................................................................................................................. 15

4.1. FUNÇÕES BÁSICAS DA APLICAÇÃO DO USUÁRIO..................................................................... 15 4.2. FUNÇÕES DIGITAIS............................................................................................................. 21 4.3. FUNÇÕES DO CONVERSOR ANALÓGICO DIGITAL (A/D) .......................................................... 25 4.4. FUNÇÕES DO CONVERSOR DIGITAL ANALÓGICO (D/A) .......................................................... 26 4.5. FUNÇÃO DO MÓDULO PWM ................................................................................................ 26 4.6. FUNÇÕES DA COMUNICAÇÃO SERIAL RS-232........................................................................ 27 4.7. FUNÇÕES DO RELÓGIO DE TEMPO REAL (RTC) ..................................................................... 32 4.8. FUNÇÕES DA MEMÓRIA SERIAL E2PROM............................................................................. 33

5. BIBLIOGRAFIA...................................................................................................................... 35

6. EXEMPLO .............................................................................................................................. 36

Manual do Usuário – Sistema Operacional McData I

1. Sistema Operacional

1.1. Definição

O sistema operacional McData, é um programa desenvolvido em linguagem C para o controle do hardware da placa e configuração do microcontrolador. O objetivo é permitir ao usuário a implementação de uma aplicação de mais alto nível a partir da utilização das funções disponíveis no sistema operacional sem a necessidade do conhecimento dos componentes do circuito.

1.2. Características

A velocidade de processamento é de 10MIPS (10 milhões de instruções por segundo). A memória de programa que o sistema ocupa é de 19% da memória total do microcontrolador que é de 32kB. A memória RAM ocupada é de aproximadamente 17% da memória total de 3968bytes.

O sistema operacional utiliza os recursos do microcontrolador PIC18F452 e executa basicamente duas tarefas: uma interrupção prioritária a cada 100us para controle das funções do sistema operacional e a aplicação do usuário. A aplicação do usuário está subdividida no programa principal e nas interrupções do usuário. Desta forma, o sistema operacional utiliza uma interrupção de alta prioridade que interrompe qualquer processo do usuário a cada 100us. Isto significa que o programa principal e as interrupções do usuário são periodicamente paralisados para atender as necessidades do sistema operacional. A interrupção do sistema operacional demanda entre 15us e 36,1us com um valor médio de 20us, de forma que os 80us restantes ficam disponíveis para a aplicação e as interrupções do usuário. Sendo assim, o usuário deve levar este fato em consideração no seu projeto e na análise de tempos e desempenho da aplicação.

Manual do Usuário – Sistema Operacional McData 1

2. Compilação

Este capítulo descreve de forma resumida o que é um compilador e quais os arquivos gerados e/ou necessários à criação de uma aplicação com o sistema operacional McData.

2.1. Definições e Arquivos do Compilador

Compilador C É um programa que converte arquivos fonte escritos em liguagem C com extensão “.c” para

arquivos objeto com extensão “.o”.

Compilador Assembler É um programa que converte arquivos fonte escritos em liguagem assmebly com extensão

“.asm” para arquivos objeto com extensão “.o”.

Arquivo linker script É um arquivo com extensão “.lkr” que contém algumas definições para divisão da memória

de dados (RAM) e a memória de programa (ROM). O linker utiliza este arquivo para saber onde alocar o programa e as variáveis de RAM no microcontrolador.

Arquivo library É um arquivo de biblioteca de funções com extensão “.lib”.

Arquivo header

É um arquivo com extensão “.h” que contém a prototipagem de funções e definição de algumas constantes. É convertido pelo compilador C para um arquivo objeto para ser utilizado pelo linker.

Linker É um programa que associa todos os arquivos objeto, os arquivos library e os arquivos

linker script e gera alguns arquivos de saída, entre eles o arquivo para gravação no compilador com extensão “.hex”.

Arquivo map É um arquivo que contém informações da compilação como quantidade de RAM e memória

de programa utilizados.

Arquivo lst É um arquivo que contém o programa em linguagem C e as respectivas instruções em

assembler do arquivo “.hex”.

Arquivo hex É um arquivo que contém o código haxadecimal que deve ser gravado no microcontrolador.

2

2.2. Diagrama de blocos de uma compilação

user01.c fuses01.asm

user01.o fuses01.o

header01.h

header01.o

Compilador C Assembler Compilador C

mcdata01.o 18f452.lkr

McData.hex

Linker

McData.mapMcData.lst

O nome dado ao projeto no MPLAB irá definir o nome dos arquivos cuja extensão é “.lst”, “.hex” e “.map”.

2.3. Arquivos do Usuário

mcdata01.o Biblioteca de funções e sistema operacional McData.

user01.c Aplicação do usuário.

fuses01.asm Configurações dos fusíveis do microcontrolador.

header01.h Arquivo que contém a definição de constantes e prototipagem das funções da biblioteca

McData.

2.4. Compilador C18

O compilador utilizado é o C18 versão V2.20 da Microchip para a família 18. A versão full


demo por 60 dias e os manuais do compilador podem ser encontrados na página: http://www.microchip.com/

2.5. Linker utilizado

O linker utilizado é o MPLINK versão 3.40 da Microchip.

4

3. Criando um projeto no MPLAB

O capítulo a seguir descreve o procedimento padrão para a criação de uma projeto no MpLab utilizando o compilador C18 da Microchip e o sistema operacional McData. No procedimento a seguir partimos do princípio que o MpLab e o compilador C18 já se encontram devidamente instalados no seu computador.

1. O primeiro passo é criar um diretório para o projeto. Todo e qualquer arquivo utilizado ou gerado pelo sistema deverá ficar armazenado neste diretório. Neste exemplo criou-se o diretório A:\McData.

2. Copie os arquivos mcdata01.o, user01.c, fuses01.asm e header01.h para este diretório. 3. No MPLAB selecione a opção Project Wizard conforme ilustração a seguir.


4. Selecione a opção Avançar na tela seguinte:

5. Selecione o microcontrolador da placa McData, neste caso o PIC18F452 e clique em Avançar.

6

6. Selecione “Microchip C18 Toolsuite” na opção “Active Toolsuite“. Em seguida, selecione

“MPLINK Object Linker (mplink.exe)” na opção “Toolsuite Contents”. Por fim, selecione Avançar.

7. Digite o nome do projeto no campo “Project Name”. Informe o diretório onde o projeto deve ser criado (no nosso exemplo A:\McData) Pode-se utilizar o botão Browse caso necessário. Depois de definir o nome do projeto e o diretório de trabalho selecione Avançar.


8. Ao visualizar a tela a seguir, selecione na janela da esquerda os quatro arquivos contidos

na pasta McData e clique em Add.

9. A tela com os 4 arquivos adicionados fica conforme o exemplo a seguir. Selecione a opção Avançar.

8

10. A tela abaixo será exibida indicando que o projeto foi criado com sucesso.

11. Clicando em Concluir a tela abaixo deverá ser exibida.


12. Clique com o botão direito do mouse sobre a opção “Linker Scripts”. Será exibido o menu

mostrado abaixo. Com o botão esquerdo do mouse clique sobre a opção “Add Files”.

13. Será exibida a tela “Add Files to Project“. Selecione no diretório no qual o compilador C18 foi instalado o arquivo 18f452.lkr e clique na opção Abrir.

10

14. No menu “Project” do MpLab escolha a opção “Project/Build Options/Project”.

15. Ao visualizar a tela abaixo selecione a opção “Suit Defaults”. Neste momento, o campo “Library Path” e “Linker Script Path” devem ser preenchidos automaticamente.


16. Selecione no campo “Include Path” o diretório do projeto utilizando o botão Browser e em seguida clique em Avançar.

17. Selecione com o mouse a guia MPLAB C18 e a tela a seguir será exibida:

12

18. Selecionar no menu “Default storage class” a opção “Static”:

19. Clique em Aplicar e OK. 20. Finalmente, temos neste ponto o projeto criado e pronto para ser compilado. A aplicação

do usuário deverá ser escrita no arquivo user.c. Por enquanto, vamos compilar o arquivo padrão apenas para verificar se todo o procedimento descrito anteriormente foi executado com sucesso. Para isso selecione a opção “Project/Buid All”.


21. Após a compilação ser concluída deverá ser exibida a tela a seguir.

22. Este é o procedimento padrão que o usuário deverá adotar para criar um projeto utilizando

o sistema operacional McData. O diretório de trabalho pode ser alterado do drive A:\ para qualquer outro drive. O importante é que todos os arquivos necessários ao projeto estejam gravados no mesmo diretório.

14

4. Funções

Este capítulo descreve todas as funções do sistema operacional McData. A fim de facilitar o entendimento as funções foram divididas em oito grupos, definidos por sua utilização e os periféricos do hardware da placa que estão relacionadas.

Algumas funções possuem um flag associado que indica que algum tipo de erro ocorreu durante a execução da função. A sintaxe do flag é sempre a seguinte: “error_nome_da_função”, por exemplo, a função digital_in_bit possui o flag error_digital_in_bit. Este flag é atualizado sempre que a função é executada e pode ser testado pelo usuário logo após o retorno da função. O flag valerá 1 quando um erro ocorrer e 0 no caso de sucesso. A declaração destes flags já está contida no arquivo header01.h, de forma que o usuário não precisa se preocupar em adicionar nenhum tipo de declaração no arquivo user.c.

4.1. Funções básicas da aplicação do usuário Este grupo de funções define a estrutura do programa uma vez que o usuário deve

escrever o código fonte de sua aplicação dentro de funções específicas contidas no arquivo user01.c.

A aplicação do usuário consiste em um programa principal, função main_loop e no tratamento de suas interrupções, funções int_timer_1ms, int_edge, int_change e int_count. Estas funções são executadas na ocorrência de suas respectivas interrupções. No entanto, na ocorrência de qualquer uma destas interrupções, o sistema operacional desvia o programa para uma região onde são salvos os registradores de contexto assim como todo e qualquer flag necessário para o correto funcionamento do microcontrolador. Desta forma, o usuário só precisa preocupar-se com a sua própria aplicação, sendo transparente toda e qualquer configuração dos registradores internos do microcontrolador.

O sistema operacional é executado dentro de uma interrupção de alta prioridade provocada por um periférico interno do microcontrolador. Esta interrupção de alta prioridade, ou seja, o sistema operacional, interrompe sempre a cada 100us a aplicação do usuário, seja durante a execução da função main_loop seja durante a execução de qualquer outra função. Portanto, mesmo as funções relativas às interrupções do usuário (int_timer_1ms, int_edge, int_change e int_count) são interrompidas pelo sistema operacional. Isto deve-se ao fato do sistema operacional McData definir as interrupções disponíveis para o usuário como interrupções da baixa prioridade.

Para todas as interrupções (exceto a do próprio sistema operacional) existem funções que podem ser utilizadas para habilitar ou inibir a ocorrência das mesmas.

O microcontrolador possui um recurso chamado watch dog timer (wdt) que nada mais é do que um contador de tempo. Este contador está configurado para contar aproximadamente um intervalo de tempo de 2,3 segundos. Ao final deste intervalo, o contador provoca um reset do microcontrolador e conseqüentemente a reinicialização da aplicação. A aplicação deve permanentemente zerar este contador em intervalos de no máximo 2,3 segundos. Este recurso é uma segurança contra uma possível falha que pode travar o programa e paralisar a aplicação. Para zerar o wdt, o usuário pode habilitar uma função do sistema operacional que zera automaticamente o wdt ou utilizar a função ClrWdt() do compilador C18. O procedimento de zerar o contador de wdt será chamado de limpar o wdt e o sistema operacional está configurado para executá-lo automaticamente. Se o usuário desejar controlar manualmente o wdt, deve desabilitar a função de zerar automaticamente e utilizar a função ClrWdt() do próprio compilador C18.

A seguir estão as características detalhadas destas funções.


auto_clrwdt_on

Função: Habilita o sistema operacional a limpar o wdt automaticamente. Prototipagem: void auto_clear_clrwdt_on(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: O sistema operacional já está configurado para zerar o watch dog

timer automaticamente. A função só faz sentido se o usuário fez uso anterior da função auto_clrwdt_off.

Exemplo: auto_clrwdt_on(); //Liga a limpeza automática do wdt //pelo sistema operacional

auto_clrwdt_off

Função: Desabilita a limpeza automática do wdt pelo sistema operacional. Prototipagem: void auto_clear_clrwdt_off(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: auto_clrwdt_off(); //Desliga a limpeza automática do wdt

//pelo sistema operacional ClrWdt(); //Limpa wdt

main_loop

Função: Tratamento do programa principal do usuário. Prototipagem: void main_loop(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: O sistema operacional McData, executa esta função continuamente

e é interrompida pelas interrupções de usuário, caso estejam em uso, e pela interrupção do sistema operacional. O usuário deve escrever dentro desta função o programa principal da sua aplicação.

Exemplo: void main_loop (void) //Programa principal { //Funções do programa principal }

int_timer_1ms_on

Função: Habilita a ocorrência da interrupção de timer. Esta interrupção ocorre a cada 1ms e o seu período de ocorrência não pode ser alterado pelo usuário.

Prototipagem: void int_timer_1ms_on(void) Argumentos de entrada: Não há.

16

Argumentos de saída: Não há. Flag de erro: Não há. Observações: Na ocorrência da interrupção o sistema operacional executará a

função int_timer_1ms(). Exemplo: int_timer_1ms_on(); //Liga a interrupção de timer a

cada1ms

int_timer_1ms_off

Função: Desabilita a ocorrência da interrupção de timer. Prototipagem: void int_timer_1ms_off(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: int_timer_1ms_off(); //Desliga a interrupção de timer

int_timer_1ms

Função: Tratamento da interrupção de timer com período de 1ms. Prototipagem: void int_timer_1ms(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Se a interrupção de timer estiver habilitada o sistema operacional

McData executa a cada 1ms esta função. É nesta função que o usuário deve escrever o tratamento da interrupção, ou seja, as instruções que devem ser executadas a cada 1ms. O contexto e os registradores internos do microcontrolador são salvos e atualizados automaticamente pelo sistema operacional.

Exemplo: void int_timer_1ms(void); //Tratamento da interrupção de 1ms { //Escrever o código do tratamento e criar variáveis locais caso

necessário }

int_on_rising_edge

Função: Habilita interrupção externa por borda de subida da entrada EDGE da placa McData.

Prototipagem: void int_on_rising_edge(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função habilita uma interrupção externa. Caso habilitada, na

ocorrência de uma borda de subida na entrada EDGE da placa McData, o sistema operacional desviará a execução do programa para a função int_edge().

Exemplo: int_on_rising_edge(); //Liga int. externa borda subida


int_on_falling_edge

Função: Habilita interrupção externa por borda de descida da entrada EDGE da placa McData.

Prototipagem: void int_on_falling_edge(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função habilita uma interrupção externa. Caso habilitada, na

ocorrência de uma borda de descida na entrada EDGE da placa McData, o sistema operacional desviará a execução do programa para a função int_edge().

Exemplo: int_on_falling_edge(); //Liga int. externa borda descida

Int_edge_off

Função: Desabilita interrupção externa por borda de subida ou descida da entrada EDGE da placa McData.

Prototipagem: void int_edge_off(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: int_edge_off(); //Desliga int. externa por borda

int_edge

Função: Tratamento da interrupção externa, seja por borda de subida ou descida.

Prototipagem: void int_edge(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função é executada pelo sistema operacional McData quando

uma interrupção externa ocorrer. O usuário deve escrever dentro desta função o tratamento da interrupção, ou seja, as instruções que devem ser executadas. O contexto e os registradores do microcontrolador são salvos e atualizados automaticamente pelo sistema operacional.

Exemplo: int_on_falling_edge(); //Liga int. externa na borda descida void int_edge(void); //Tratamento da interrupção externa { //Escrever o tratamento e criar variáveis caso necessário int_edge_off(); //Desliga int. externa borda descida

//que neste exemplo só ocorre uma //única vez

}

18

int_change_on

Função: Habilita interrupção por mudança de estado da entrada CHANGE da placa McData.

Prototipagem: void int_change_on(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função habilita a interrupção de mudança de estado. Caso a

interrupção esteja habilitada, ao ocorrer uma mudança de estado na entrada CHANGE da placa McData, o sistema operacional irá executar a função int_change().

Exemplo: int_change_on(); //Liga int. de mudança de estado

int_change_off

Função: Desabilita interrupção por mudança de estado da entrada CHANGE da placa McData.

Prototipagem: void int_change_off(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: int_change_off(); //Desliga int. de mudança de estado

int_change

Função: Tratamento da interrupção de mudança de estado. Prototipagem: void int_change (void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função é executada pelo sistema operacional McData quando

uma interrupção de mudança de estado ocorrer. O usuário deve escrever dentro desta função o tratamento da interrupção, ou seja, as instruções que devem ser executadas. O contexto e os registradores do microcontrolador são salvos e atualizados automaticamente pelo sistema operacional.

Exemplo: int_change_on(); //Liga interrupção por mudança //de estado

void int_change(void); //Tratamento da interrupção { //Escrever o tratamento e criar variáveis caso necessário }


int_count_on

Função: Habilita interrupção de contagem de pulsos na entrada COUNT da placa McData.

Prototipagem: void int_count_on(unsigned int). Argumentos de entrada: Número de pulsos que devem ser contados. É um número de 16 bits

do tipo unsigned int. Argumentos de saída: Não há. Flag de erro: Não há.| Observações: Esta função habilita a interrupção de fim de contagem do número de

pulsos estabelecidos. No fim da contagem, ou seja, na borda de subida do último pulso, o sistema operacional irá executar a função int_count(). A contagem dos pulsos utiliza o periférico timer 0 do PIC incrementado externamente pela entrada COUNT.

Exemplo: int_count_on(2000); //Liga int. para contagem de 2.000 //pulsos

Int_count_off

Função: Desabilita interrupção de contagem de pulsos na entrada COUNT da placa McData.

Prototipagem: void int_count_off(unsigned int) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: int_count_off(); //Desliga int. de contagem de pulsos

int_count Função: Tratamento da interrupção de contagem de pulsos. Prototipagem: void int_count(void) Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função é executada pelo sistema operacional McData quando a

contagem de pulsos chega ao fim, ou seja, na borda de subida do último pulso. O usuário deve escrever dentro desta função o tratamento da interrupção, ou seja, as instruções que devem ser executadas. O contexto e os registradores do microcontrolador são salvos e atualizados automaticamente pelo sistema operacional. Ao tratar a interrupção, uma nova contagem é automaticamente iniciada. Caso o usuário queira mudar o número da contagem deve executar a função desliga_int_contagem e depois liga_int_contagem novamente com a nova quantidade de contagem.

Exemplo: int_count_on(2000); //Liga int para contar 2000 pulsos

20

void int_count(void); //Tratamento da interrupção { //Escrever o tratamento e criar variáveis caso necessário //Automaticamente o sistema operacional irá inicializar uma //nova contagem de 2000 pulsos }

4.2. Funções Digitais

O conjunto de funções deste bloco permitem o acesso às entradas e saídas digitais, leds, botões e buzzer da placa McData.

digital_in Função: Leitura das 8 entradas digitais. Prototipagem: unsigned char digital_in(void). Argumentos de entrada: Não há. Argumentos de saída: Retorna em 8 bits o estado das entradas digitais. Flag de erro: Não há. Observações: A variável que receberá o valor de retorno desta função deve ser do

tipo unsigned char cujo bit 0 é o estado da entrada digital 0, o bit 1 é o estado da entrada digital 1 e assim sucessivamente até o bit 7.

Exemplo: entradas = digital_in(); //leitura das 8 entradas digitais

digital_in_bit Função: Leitura de uma entrada digital. Prototipagem: unsigned char digital_in_bit(unsigned char). Argumentos de entrada: Número do bit da entrada digital que será lida. Este número é de 8

bits, não sinalizado e pode variar de 0 a 7, relativo ao número do bit da entrada digital.

Argumentos de saída: Retorna em 8 bits o estado da entrada digital. Se a entrada está em nível lógico 0, retorna o número 0, senão, retorna o número 1.

Flag de erro: O flag error_digital_in_bit indica sucesso se o argumento de entrada é válido, ou seja, um número entre 0 e 7, senão, indica erro e o argumento de saída é forçado em zero.

Observações: Não há. Exemplo: estado = digital_in_bit(0); //Leitura do estado da entrada digital 7 //flag error_digital_in_bit=0

digital_out Função: Escrita na saídas digitais. Prototipagem: void digital_out(unsigned char). Argumentos de entrada: Recebe valor de 8 bits que será carregado nas saídas digitais. Argumentos de saída: Não há. Flag de erro: Não há.


Observações: A saída digital 0 é atualizada com o conteúdo do bit 0 do argumento de entrada e assim sucessivamente até o bit 7.

Exemplo: digital_out(0x80); //As saídas vão para nível lógico 0 //exceto a saída 7 que vai para nível //lógico 1

digital_out_bit_off

Função: Força nível lógico 0 em uma saída digital. Prototipagem: void digital_out_bit_off(unsigned char). Argumentos de entrada: Número da saída digital que irá para nível lógico 0. Este número é

de 8 bits, não sinalizado e pode variar de 0 a 7, relativo ao número do bit da saída digital.

Argumentos de saída: Não há. Flag de erro: O flag error_digital_out_bit_off indica sucesso se o argumento de

entrada é válido, senão, indica erro. Em caso de erro nenhuma saída digital é alterada.

Observações: Não há. Exemplo: digital_out_bit_off(7); //Força nível lógico 0 no bit 7 da saída

//digital //flag error_digital_in_bit=0

digital_out_bit_on Função: Força nível lógico 1 em uma saída digital. Prototipagem: void digital_out_bit_on(unsigned char). Argumentos de entrada: Número da saída digital que irá para nível lógico 1. Este número é

de 8 bits, não sinalizado e pode variar de 0 a 7, relativo ao número do bit da saída digital.

Argumentos de saída: Não há. Flag de erro: O flag error_digital_out_bit_on indica sucesso se o argumento de

entrada é válido, senão, indica erro. Neste caso, nenhuma saída digital é alterada.

Observações: Não há. Exemplo: digital_out_bit_on(7); //Força nível lógico 1 no bit 7 da saída

//digital //O flag error_digital_in_bit=0

button Função: Leitura do estado de um botão. Prototipagem: unsigned button(unsigned char). Argumentos de entrada: Número do botão que será lido. Este número é de 8 bits, não

sinalizado e pode variar de 1 a 4 referente às chaves SW1 a SW4 da placa McData.

Argumentos de saída: Retorna em 8 bits não sinalizados o estado do botão. Se o botão estiver pressionado retorna o número 1, se solto retorna o número 0.

Flag de erro: O flag error_button indica sucesso se o argumento de entrada é válido, senão, indica erro e força o argumento de saída em zero.

Observações: Esta função já possui um filtro de 20ms para eliminar o ruído

22

provocado pelo bouncing dos botões. No entanto, a função não trava o sistema durante este intervalo pois é o próprio sistema operacional da placa McData que checa o estado do botão.

Exemplo: if ( button(1) == 1 ) { //Tratamento para botão 1 pressionado }

led_on Função: Acende um dos leds da placa McData. Prototipagem: void led_on(unsigned char). Argumentos de entrada: Número do led que irá acender. Este número é de 8 bits, não

sinalizado e pode variar de 1 a 4, relativo aos leds L1 a L4 da placa McData.

Argumentos de saída: Não há. Flag de erro: O flag error_led_on indica sucesso se o argumento de entrada é

válido, senão, indica erro e o estado dos leds não é alterado. Observações: Não há. Exemplo: led_on(4); //Acende led 4

led_off Função: Apaga um dos leds da placa McData. Prototipagem: void led_off(unsigned char). Argumentos de entrada: Número do led que irá apagar. Este número é de 8 bits, não

sinalizado e pode variar de 1 a 4, relativo aos leds L1 a L4 da placa McData.

Argumentos de saída: Não há. Flag de erro: O flag error_led_off indica sucesso se o argumento de entrada é

válido, senão, indica erro e o estado dos leds não é alterado. Observações: Não há. Exemplo: Led_off(4); //Apaga led 4

buzzer_on Função: Liga o buzzer por tempo indeterminado. Prototipagem: void buzzer_on(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Não há. Exemplo: buzzer_on(); //Liga buzzer

buzzer_off Função: Desliga o buzzer. Prototipagem: void buzzer_off(void). Argumentos de entrada: Não há. Argumentos de saída: Não há.


Flag de erro: Não há. Observações: Não há. Exemplo: buzzer_off(); //Desliga buzzer

beep Função: Emite um beep no buzzer. Prototipagem: void beep(unsigned char). Argumentos de entrada: Tempo de duração do beep que é um número 8 bits, não sinalizado

e pode variar de 1 a 255. Argumentos de saída: Não há. Flag de erro: O flag error_beep indica sucesso se o argumento de entrada é

válido, senão, indica erro. Em caso de erro nenhum som é emitido pelo buzzer.

Observações: Esta função utiliza uma base de tempo de 10ms, o que define que em 255 o beep tocará durante 2550ms. A função não trava o processamento durante este intervalo de tempo.

Exemplo: beep(8); //Toca beep por 80ms

delay_100us

Função: Delay em múltiplos de 100us. Prototipagem: void delay_100us (unsigned char). Argumentos de entrada: Tempo de delay que é um número 8 bits, não sinalizado e pode

variar de 1 a 255. Argumentos de saída: Não há. Flag de erro: O flag error_delay_100us indica sucesso se o argumento de entrada

é válido, senão, indica erro. Em caso de erro nenhum delay é executado e o programa retorna imediatamente após a chamada da função.

Observações: Esta instrução só é finalizada ao final do tempo determinado, ou seja, esta função paralisa o sistema durante sua execução. Esta função limpa o wacth dog timer independentemente dele estar configurado em automático ou manual.

Exemplo: delay_100us(20); //Delay de 20 x 100us = 2ms

delay_10ms

Função: Delay em múltiplos de 10ms. Prototipagem: void delay_10ms (unsigned char). Argumentos de entrada: Tempo de delay que é um número 8 bits, não sinalizado e pode

variar de 1 a 255. Argumentos de saída: Não há. Flag de erro: O flag error_delay_10ms indica sucesso se o argumento de entrada

é válido, senão, indica erro. Em caso de erro nenhum delay é executado e o programa retorna imediatamente após a chamada da função.

Observações: Esta instrução só é finalizada ao final do tempo determinado, ou seja, esta função paralisa o sistema durante sua execução. Esta

24

função limpa o wacth dog timer independentemente dele estar configurado em automático ou manual.

Exemplo: delay_10ms(200); //Delay de 200 x 10ms = 2s

4.3. Funções do Conversor Analógico Digital (A/D)

As funções a seguir são utilizadas para a aquisição de dados utilizando as entradas analógicas da placa McData.

analog_in_8bits Função: Leitura de uma entrada analógica com 8 bits de resolução. Prototipagem: unsigned char analog_in_8bits(unsigned char). Argumentos de entrada: Número da entrada analógica que irá ser lida. Este número é de 8

bits, não sinalizado e pode variar de 0 a 7, relativo as entradas analógicas da placa McData.

Argumentos de saída: Retorna em 8 bits não sinalizados o valor da conversão A/D da entrada analógica.

Flag de erro: O flag error_analog_in_8bits indica sucesso se o argumento de entrada é válido, senão, indica erro e força o argumento de saída em zero.

Observações: O sistema operacional converte a cada 2ms um canal, como a placa possui 8 canais são necessários 16ms para a aquisição de todos os canais, o que define uma frequência de amostragem de 62,5Hz por canal.

Exemplo: aux=analog_in_8bits(0); //Lê canal 0 da entrada analógica com //8 bits de resolução

analog_in_10bits

Função: Leitura de uma entrada analógica com 10 bits de resolução. Prototipagem: unsigned int analog_in_10bits(unsigned char). Argumentos de entrada: Número da entrada analógica que irá ser lida. Este número é de 8

bits, não sinalizado e pode variar de 0 a 7, relativo as entradas analógicas da placa McData.

Argumentos de saída: Retorna em 16 bits não sinalizados o valor da conversão A/D da entrada analógica.

Flag de erro: O flag error_analog_in_10bits indica sucesso se o argumento de entrada é válido, senão, indica erro e força o argumento de saída em zero.

Observações: O sistema operacional converte a cada 2ms um canal, como a placa possui 8 canais são necessários 16ms para a aquisição de todos os canais, o que define uma frequência de amostragem de 62,5Hz por canal.

Exemplo: aux=analog_in_10bits(0); //Lê canal 0 da entrada analógica com //10 bits de resolução


4.4. Funções do Conversor Digital Analógico (D/A)

A função a seguir é utilizada para a geração de sinais analógicos na saída analógica da placa McData.

analog_out

Função: Define o valor da tensão de uma das saídas analógicas em volts. Prototipagem: void analog_out(unsigned char, unsigned char). Argumentos de entrada: Número da saída analógica e o respectivo valor de tensão. O

número da saída analógica é de 8 bits, não sinalizado e pode ser 1 ou 2. O valor da tensão é um número de 8 bits, não sinalizado e pode variar entre 0 e 50 relativo à 0,0V e 5,0V.

Argumentos de saída: Não há. Flag de erro: O flag error_analog_out indica sucesso se os argumentos de entrada

são válidos, senão, indica erro. Em caso de erro as saídas não são alteradas.

Observações: A saída analógica varia de 0 a 5Vdc com passos de 0,1V. É por este motivo que o argumento de entrada varia de 0 a 50. Esta saída é gerada a partir de um PWM que está ligado a um filtro passa-baixa com constante de tempo de 0,1s, o que define que a máxima freqüência de amostragem destas saídas é de 2Hz.

Exemplo: analog_out(2,15); //Saída 2 em 1,5V

4.5. Função do módulo PWM

As funções a seguir são utilizadas para definir a frequência e o duty-cycle das saídas PWM da placa McData.

pwm_out Função: Atualiza o duty-cycle de uma das duas saídas PWM. Prototipagem: void pwm_out(unsigned char, unsigned int). Argumentos de entrada: Número da saída PWM e o respectivo valor de duty-cycle. O número

da saída PWM é de 8 bits, não sinalizado e pode ser 1 ou 2. O duty-cycle é um número de 16 bits, não sinalizado e pode variar de 0 a 1000.

Argumentos de saída: Não há. Flag de erro: O flag error_pwm_out indica sucesso se os argumentos de entrada

são válidos, senão, indica erro. Em caso de erro as saídas não são alteradas.

Observações: O argumento de entrada pode variar de 0 a 1000 pois o duty-cycle do PWM pode ser ajustado de 0,1% em 0,1%. As saídas PWM utilizam o periférico de hardware do microcontrolador. A freqüência de trabalho é configurada pelas funções específicas de ajuste de frequência.

Exemplo: pwm_out(2,500); //Configura PWM 2 com 50% de duty-//cycle

26

pwm_out_2500

Função: Atualiza a freqüência das duas saídas PWM para 2500Hz. Prototipagem: void pwm_out_2500(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função não altera o duty-cycle das saídas. Exemplo: pwm_out_2500(); //Configura freqüência do pwm

pwm_out_10000 Função: Atualiza a freqüência das duas saídas PWM para 10000Hz. Prototipagem: void pwm_out_10000(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função não altera o duty-cycle das saídas. Exemplo: pwm_out_10000(); //Configura freqüência do pwm

pwm_out_40000

Função: Atualiza a freqüência das duas saídas PWM para 40000Hz. Prototipagem: void pwm_out_40000(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: Esta função não altera o duty-cycle das saídas. Exemplo: pwm_out_40000(); //Configura freqüência do pwm

4.6. Funções da comunicação serial RS-232

As funções a seguir são utilizadas na comunicação serial padrão RS-232 para enviar e receber dados, definir a velocidade da comunicação e controlar o fluxo de dados.

As configurações da comunicação são: sem paridade, 8 bits de dados e 1 stop bit. Esta configuração é denominada 8N1 e não pode ser alterada pelo usuário.

O controle de fluxo por hardware utilizado é o controle por RTS/CTS. A placa McData implementa a conexão null modem, que trança os pinos de TXD com RXD e RTS com CTS no circuito da placa. Isto implica que o cabo para interligação de um computador à placa McData não precisa ser trançado. Para padronizar a simbologia, o sinal de CTS neste manual é o sinal de entrada na placa McData utilizado pelo sistema operacional para detectar que o computador está apto a receber dados ou, que está cheio e a placa não pode enviar dados. O sinal de RTS, é o sinal de saída na placa McData, utilizado pelo sistema operacional para informar ao computador que a placa está pronta para receber dados ou, que está com o buffer de recepção cheio, travando o envio de dados pelo computador. O buffer para recepção de dados pelo sistema


operacional é de 16 bytes. O tamanho deste buffer de recepção não pode ser alterado pelo usuário.

O sistema operacional da McData utiliza o periférico de USART do microcontrolador PIC para implementar a comunicação.

buffer_rs232

Função: Informa a quantidade de bytes no buffer de recepção da comunicação RS-232.

Prototipagem: char buffer_rs232t(void). Argumentos de entrada: Não há. Argumentos de saída: Retorna o número de bytes no buffer. A variável que irá receber o

retorno desta função deve ser de 8 bits do tipo char. Flag de erro: O flag error_buffer_rs232 pode indicar duas situações de erros

diferentes. Na primeira situação um byte é recebido, porém, o buffer de recepção está cheio. Neste caso o buffer é preservado mas o byte recebido é perdido. A segunda situação é quando ocorre um erro no frame. Neste caso todos os bytes do buffer são perdidos. Sempre que a função é executada o flag de erro é atualizado para o estado de sucesso. O sistema operacional muda automaticamente o estado deste flag quando algum erro ocorre, ou seja, uma vez detectado um erro, a função buffer_rs232 deve ser executada para limpar o flag de erro e habilitar o sistema a detectar uma nova situação de erro.

Observações: Não há. Exemplo: if (error_buffer_rs232==0) //Ocorreu algum erro na recepção? { //Não, comunicação sem erros if(buffer_rs232()!=0) //Há bytes recebidos no buffer? {

data=read_rs232t(); //Sim, lê byte recebido }

} else {

///Trata a ocorrência de erro na RS232 }

read_rs232

Função: Lê o primeiro byte recebido que está no buffer de recepção da comunicação RS-232.

Prototipagem: char read_rs232t(void). Argumentos de entrada: Não há. Argumentos de saída: Retorna o byte lido do buffer de recepção. A variável que irá receber

o retorno desta função deve ser de 8 bits do tipo char. Flag de erro: O flag error_read_rs232 indica erro se a função for executada e o

buffer estiver vazio. Neste caso o argumento de saída é forçado em

28

zero, senão, o flag indica sucesso e a função retorna o dado lido. Observações: Quando um byte é recebido, ele é armazenado na próxima posição

livre do buffer de recepção, cuja capacidade é de 16 bytes. O controle de fluxo por hardware, se estiver habilitado, afeta o funcionamento desta função. Para maiores informações consultar as funções flow_control_rs232_on e flow_control_rs232_off.

Exemplo: if(buffer_rs232()!=0) //Há bytes recebidos no buffer? {

data=read_rs232t(); //Sim, lê byte }

write_rs232

Função: Transmite um byte pela RS-232. Prototipagem: void write_rs232(char). Argumentos de entrada: O dado a ser transmitido deve ser de 8 bits do tipo char. Argumentos de saída: Não há. Flag de erro: O flag error_write_rs232 indica erro se o byte não for transmitido.

Isto pode ocorrer se o usuário tentar enviar um novo dado antes de finalizar a transmissão anterior ou se o controle de fluxo por hardware estiver ligado e a placa detectar, através do sinal CTS, que o computador não está pronto para receber novos dados.

Observações: A função write_rs232 não aguarda o fim da transmissão do byte. Como não existe um buffer de transmissão o usuário deve garantir o tempo entre as transmissões para enviar o próximo byte. O controle de fluxo por hardware afeta o funcionamento desta função, ver as funções flow_control_rs232_on e flow_control_rs232_off.

Exemplo: write_rs232(0x41); //Envia o byte 0x41 If (erro_write_rs232==1) //Ocorreu erro na transmissão? { //Sim, o byte não foi transmitido }

flow_control_rs232_on

Função: Liga o controle de fluxo de dados por hardware do tipo RTS/CTS. Prototipagem: void flow_control_rs232_on(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: O controle de fluxo habilita o uso dos sinais CTS e RTS na recepção

e transmissão de dados influenciando no funcionamento das funções read_rs232 e write_rs232. Se o buffer de recepção enche, o sinal de RTS vai automaticamente para nível lógico 1 informando o transmissor que a placa McData não está pronta para receber novos dados. Nesta situação, se o usuário ler um byte do buffer com o comando read_rs232, o sinal de RTS volta para 0 liberando o transmissor a enviar mais dados. O sinal de CTS bloqueia o envio de dados pela McData pois o receptor está ocupado.


Exemplo: fllow_control_rs232_on(); //Liga controle de fluxo por hardware //da RS-232

flow_control_rs232_off

Função: Desliga o controle de fluxo por hardware dados pela RS-232. Prototipagem: void flow_control_rs232_off(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: A comunicação continua funcionando normalmente. O usuário pode

implementar o controle de fluxo utilizando as funções rst_on, rts_off e cts_in.

Exemplo: flow_control_rs232_off(); //Desliga controle de fluxo por //hardware da RS-232

rts_on

Função: Força nível lógico 1 no pino de RTS. Prototipagem: void rts_on(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: O flag error_rts_on indica erro se o usuário executar esta função

com o controle de fluxo por hardware ligado. Observações: Utilizado pelo usuário para implementar o controle de fluxo

informando que a placa McData não pode receber dados. Exemplo: rts_on(); //Envia sinal de RTS em 1

rts_off Função: Força nível lógico 0 no pino de RTS. Prototipagem: void rts_off(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: O flag error_rts_off indica erro se o usuário executar esta função

com o controle de fluxo por hardware ligado. Observações: Utilizado pelo usuário para implementar o controle de fluxo

informando que a placa McData está pronta para receber dados. Exemplo: rts_off(); //Envia sinal de RTS em 0

cts_in

Função: Leitura do sinal CTS. Prototipagem: unsigned cts_in(void). Argumentos de entrada: Não há. Argumentos de saída: Retorna em 8 bits o estado do pino CTS. Se o pino estiver em nível

lógico 1 a função retorna o número 1, senão retorna o número 0. Flag de erro: Não há. Observações: O usuário pode implementar o controle de fluxo utilizando esta

função.

30

Exemplo: if (cts_in()==1) //CTS=1? { //Sim, a placa McData pode enviar write_rs232(0x01); //Envia byte }

rs232_2400

Função: Configura o baud rate da RS-232 para 2400 bps. Prototipagem: void rs232_2400(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: O usuário deve obrigatoriamente configurar o baud rate da

comunicação antes de utilizar as funções read_rs232 e write_rs232. Exemplo: rs232_2400(); //Configura baud rate p/ 2400bps

rs232_4800 Função: Configura o baud rate da RS-232 para 4800 bps. Prototipagem: void rs232_4800(void). Argumentos de entrada: Não há. Argumentos de saída: Não há. Flag de erro: Não há. Observações: O usuário deve obrigatoriamente configurar o baud rate da







4.7. Funções do relógio de tempo real (RTC)

As funções a seguir são utilizadas para acessar e manipular os dados do relógio de tempo real (RTC) da placa McData utilizando o barramento de comunicação I2C. A velocidade do clock gerado pela placa McData é de 100KHz. O sistema operacional configura a placa McData para trabalhar como Master na rede I2C. O relógio possui o endereço físico 0x00 nesta rede.

write_pcf8583

Função: Escrita no relógio de tempo real PCF8583 da Philips pela rede I2C. Prototipagem: void write_pcf8583(void). Argumentos de entrada: Os parâmetros de entrada desta função são seis variáveis de 8 bits

do tipo unsigned char: seg_relogio, min_relogio, hora_relogio, dia_relogio, mes_relógio e ano_relógio. Estas variáveis estão declaradas como globais do tipo extern no arquivo header01.h pois já foram declaradas como globais no programa mcdata.o. Para acertar o relógio, o usuário deve atualizar as seis variáveis mencionadas e executar esta função.

Argumentos de saída: Não há. Flag de erro: O flag error_write_pcf8583 é utilizado para indicar a ocorrência de

dois erros, primeiro, uma colisão no barramento I2C ou o segundo, o não recebimento do sinal de acknowledge. Caso um dos dois erros seja detectado, a função é imediatamente finalizada.

Observações: O ano deve ser um número de 0 a 3. O usuário deve utilizar esta variável para atualizar os dois bits menos significativos do ano. Por exemplo, se o ano é 2003, a variável ano_relogio deve valer 0x03, se o ano é 2004, deve valer 0x00 e se o ano é 2005, deve valer 0x01, ou seja, sempre os dois bits menos significativos do ano. É importante acertar corretamente o ano do relógio para que o mesmo leve em consideração o ano bissexto. O ano bissexto é sempre divisível por 4 e portanto os dois últimos bits valem sempre 0x00.

Exemplo: seg_relogio=0x15; //Hora: 14:57:15 min_relogio=0x57; hora_relogio=0x14; dia_relogio=0x22; //Data: 22/01/03 mes_relogio=0x01; ano_relogio=0x03; write_pcf8583(); //Acerta a data e hora do relógio

read_pcf8583

Função: Leitura do relógio tempo real PCF8583 da Philips pela rede I2C. Prototipagem: void read_pcf8583(void). Argumentos de entrada: Não há. Argumentos de saída: Os parâmetros de saída desta função são seis variáveis de 8 bits do

tipo unsigned char: seg_relogio, min_relogio, hora_relogio, dia_relogio, mes_relógio e ano_relógio. Estas variáveis estão declaradas como globais do tipo extern no arquivo header01.h pois já foram declaradas como globais no programa mcdata.o do sistema

32

operacional McData. O usuário pode utilizar as seis variáveis mencionadas depois de executar a função read_pcf8583.

Flag de erro: O flag error_read_pcf8583 é utilizado para indicar a ocorrência de dois erros, primeiro, uma colisão no barramento I2C ou o segundo, o não recebimento do sinal de acknowledge. Caso um dos dois erros seja detectado, a função é imediatamente finalizada.

Observações: O ano deve ser um número de 0 a 3. O usuário deve utilizar esta variável para atualizar os dois bits menos significativos do ano. Por exemplo, se o ano é 2003, a variável ano_relogio deve valer 0x03, se o ano é 2004, deve vale 0x00 e se o ano é 2005, deve valer 0x01.

Exemplo: read_pcf8583(); //Lê o relógio. Após a função as seis // variáveis foram atualizadas e podem // ser utilizadas

4.8. Funções da memória serial E2PROM

As funções a seguir permitem o acesso de leitura e escrita na memória serial E2PROM da placa McData utilizando o barramento de comunicação I2C. Além da memória presente na placa outras memórias podem ser conectadas neste barramento. As funções podem ser utilizadas para acessar tanto a memória já existente como outra ligada externamente. A velocidade do clock gerado pela placa McData é de 100KHz. O sistema operacional configura a placa McData para trabalhar como Master na rede I2C. A placa McData liga os pinos A2, A1 e A0 da memória para nível lógico 1, o que determina o endereço físico da memória E2PROM na rede. As memórias da Microchip 24C256 terão o endereço 0x07 e as memórias da Atmel, que não possuem o pino de endereçamento A2, terão o endereço físico 0x03 na rede I2C. Outras memórias conectadas ao barramento I2C não podem ter o mesmo endereço da memória da placa ou do relógio cujo endereço físico é 0x00. O usuário deve definir o endereço da memória escrevendo na variável eeprom_address um número entre 0x01 e 0x07 (o endereço 0x00 já está reservado para o relógio RTC). Por padrão, o sistema operacional está configurado para utilizar o endereço 0x03, ou seja, por padrão, a placa utiliza a memória 24C256 da Atmel. Caso a placa McData esteja utilizando a memória da Microchip o usuário deve alterar o endereço para 0x07.

write_eeprom

Função: Escrita de um byte na memória E2PROM 24C256 da placa ou do barramento I2C.

Prototipagem: void write_eeprom(unsigned int, unsigned char). Argumentos de entrada: Dois parâmetros, o endereço do dado na memória e o próprio dado.

O endereço é uma variável de 16 bits do tipo unsigned int e o dado, uma variável de 8 bits do tipo unsigned char.

Argumentos de saída: Não há. Flag de erro: O flag error_write_eeprom é utilizado para indicar a ocorrência de

três erros, primeiro, uma colisão no barramento I2C, o segundo, o não recebimento do sinal de acknowledge, ou o terceiro, o valor da variável eeprom_address não é válido. Caso um dos erros seja detectado, a função é imediatamente finalizada.

Observações: Antes de utilizar a função a variável global eeprom_address deve ser


atualiza com um número de 0x01 a 0x07 relativo ao endereço físico da memória na rede I2C. Por padrão, o sistema operacional utiliza o endereço 0x03.

Exemplo: eeprom_address=0x03; //Endereço físico da memória na rede write_eeprom(0x1FF,0xB8); //salva o dado 0xB8 no endereço //0x1FF da memória

read_eeprom

Função: Leitura de um byte da memória E2PROM 24C256 da placa ou do barramento I2C.

Prototipagem: void read_eeprom(unsigned int). Argumentos de entrada: Variável de 16 bits do tipo unsigned int que define o endereço do

dado a ser lido da memória. Argumentos de saída: Não há. Flag de erro: O flag error_write_eeprom é utilizado para indicar a ocorrência de

três erros, primeiro, uma colisão no barramento I2C, o segundo, o não recebimento do sinal de acknowledge, ou o terceiro, o valor da variável eeprom_address não é válido. Caso um dos erros seja detectado, a função é imediatamente finalizada.

Observações: Antes de utilizar a função a variável global eeprom_address deve ser atualiza com um número de 0x01 a 0x07 relativo ao endereço físico da memória na rede I2C. Por padrão, o sistema operacional utiliza o endereço 0x03.

Exemplo: //declaração das variáveis unsigned char dado; //dado da E2PROM //exemplo de uso da função eeprom_address=0x03; //Endereço físico da memória na rede dado=read_eeprom(0x1FF); //Lê o dado do endereço 0x01FF

34

5. Bibliografia

1) Microchip. MPLAB® – C18 Compiler Libraries (Manual das bibliotecas de funções do compilador);

2) Microchip. MPLAB® – C18 Compiler user’s guide (Manual do compilador);

3) Schildt, Herbert. C completo e total 3a. edição. Markron blooks.

A referências da Microchip podem ser encontradas no link: http://www.microchip.com/1010/pline/tools/picmicro/code/mplab18/index.htm


6. Exemplo

• O exemplo é o arquivo ex01.c detalhadamente explicado; • É um exemplo completo com declaração de variáveis locais e globais do usuário; • São criados também flags para implementação da lógica de tratamento dos botões; • O programa utiliza a clear watch dog automático; • Na inicialização, as saídas digitais são forçadas para nível lógico zero • O byte do endereço 0x000 da E2PROM é lido e salvo no endereço 0x001 • O relógio é atualizado para 14:57 do dia 22/01/03; • O controle de fluxo por hardware da RS232 é ativado, o baud rate é ajustado para

9600bps; • A freqüência do PWM é ajustada para 10kHz; • Todas as interrupções são habilitadas; • A contagem de pulsos é configurada para que ocorra a cada pulso; • Se for detectado algum erro na escrita da memória E2PROM, um beep longo será

emitido; • Dois beeps longos serão emitidos se ocorrer um erro na escrita do relógio; • A interrupção de 1ms implementa uma rampa nas saídas analógicas e nas saídas

PWM; • No tratamento das demais interrupções um beep de 80ms é emitido; • As 4 teclas invertem o estado dos respectivos leds e um beep de 80ms é emitido; • Com o led L1 aceso, o software copia o estado das entradas digitais para as saídas

digitais; • Com o led L1 apagado o software testa se as entradas analógicas são maiores que

2,5V. Em caso afirmativo acende os respectivos leds das saídas digitais; • Com o led L2 aceso o software testa a porta serial, enviando um byte e checando a

sua recepção. O programa ainda força os dois estados, um e zero, no pino RTS e testa se os mesmos foram recebidos no pino CTS. Caso uma falha nestes testes seja detectada o buzzer toca continuamente. Para que este teste funcione, o usuário deve curto-circuitar o pino 2 com o pino 3 e o pino 7 com o pino 8 do conector DB9;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * SOFTWARE DE USUÁRIO P/ PLACA MCDATA * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * ex01.C - SOFTWARE DE TESTE DA MCDATA * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * DEFINIÇÃO DO PROCESSADOR * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #include <p18F452.h> // Register definitions // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * ARQUIVOS DE INCLUDE * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #include <header01.h> //PROTOTIPAGEM DAS FUNÇÕES

36

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * CONSTANTES * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //Nesta região devem ser declaradas constantes de programação // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * DECLARAÇÃO DE VARIÁVEIS GLOBAIS DE USUÁRIO * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //Nesta região devem ser declaradas as variáveis glogais static union { struct { unsigned F0:1; unsigned F1:1; unsigned F2:1; unsigned F3:1; unsigned F4:1; unsigned F5:1; unsigned F6:1; unsigned F7:1; unsigned F8:1; unsigned F9:1; } ; }FLAGSbits; //Registrador de flags de entrada unsigned int aux_cont=0, contador=0; //auxiliar p/ gerar rampas unsigned char tempo=0; //auxiliar p/ gerar rampas // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * DEFINIÇÃO DE FLAGS * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //Nesta região devem ser declaradas os flags #define F_BOT1 FLAGSbits.F0 //FLAG 1->BOTAO TRATADO 0->BOTAO NAO TRATADO #define F_BOT2 FLAGSbits.F1 //FLAG 1->BOTAO TRATADO 0->BOTAO NAO TRATADO #define F_BOT3 FLAGSbits.F2 //FLAG 1->BOTAO TRATADO 0->BOTAO NAO TRATADO #define F_BOT4 FLAGSbits.F3 //FLAG 1->BOTAO TRATADO 0->BOTAO NAO TRATADO #define F_TESTE FLAGSbits.F4 //FLAG DE TESTE DA PLACA #define F_FF1 FLAGSbits.F5 //FLAG #define F_FF2 FLAGSbits.F6 //FLAG #define F_FF3 FLAGSbits.F7 //FLAG #define F_FF4 FLAGSbits.F8 //FLAG #define F_RAMPA FLAGSbits.F9 //FLAG // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * ROTINAS DE USUÁRIO * // * * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //Nesta região devem ser escritas as rotinas do usuário void testa_analog(void) { unsigned int aux; //auxiliar p/ medidas do ad aux=analog_in_8bits(0); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(0); else digital_out_bit_off(0); aux=analog_in_8bits(1); //Lê entrada analógica com 8 bits


if (aux>128) digital_out_bit_on(1); else digital_out_bit_off(1); aux=analog_in_8bits(2); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(2); else digital_out_bit_off(2); aux=analog_in_8bits(3); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(3); else digital_out_bit_off(3); aux=analog_in_8bits(4); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(4); else digital_out_bit_off(4); aux=analog_in_8bits(5); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(5); else digital_out_bit_off(5); aux=analog_in_8bits(6); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(6); else digital_out_bit_off(6); aux=analog_in_8bits(7); //Lê entrada analógica com 8 bits if (aux>128) digital_out_bit_on(7); else digital_out_bit_off(7); } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * LOOP DA APLICAÇÃO * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void main_loop(void) //LOOP DE USUARIO { // * * * * * * * * * * * * DECLARAÇÃO DE VARIÁVEIS LOCAIS DE USUÁRIO * * * * * * * * * //Nesta região devem ser declaradas as variáveis locais do programa principal unsigned char ee_dado; //dado da e2prom unsigned int ee_end; //end da e2prom char data; //Variável para teste da serial // * * * * * * * * * * * * * * * * * * * * Inicializações * * * * * * * * * * * * * * * //Nesta região devem ser feitas as inicializações do programa digital_out(0X00); //Inicia todas as saídas digitais em zero eeprom_address=0x03; //Endereço da e2prom na rede I2C para memória Atmel //Memória Microchip deve ser 0x07 ee_dado=read_eeprom(ee_end); //lê byte da e2prom write_eeprom(ee_end+1,ee_dado); //escreve byte na e2prom if (error_write_eeprom==1) //Ocorreu um erro na escrita na memória? { buzzer_on(); //Liga beep delay_10ms(100); //Delay múltiplo de 10ms (1s) buzzer_off(); //Desliga beep delay_10ms(25); //Delay múltiplo de 10ms (0,25s) } read_pcf8583(); //Acerta relógio min_relogio=0x57; //Data: 22/01/03 hora_relogio=0x14; //Hora: 14:57 dia_relogio=0x22; mes_relogio=0x01; ano_relogio=0x03; write_pcf8583(); //Acerta relógio

38

if (error_write_pcf8583==1) //Ocorreu um erro na escrita do relógio? { buzzer_on(); //Liga beep delay_10ms(100); //Delay múltiplo de 10ms (1s) buzzer_off(); //Desliga beep delay_10ms(25); //Delay múltiplo de 10ms (0,25s) buzzer_on(); //Liga beep delay_10ms(100); //Delay múltiplo de 10ms (1s) buzzer_off(); //Desliga beep delay_10ms(25); //Delay múltiplo de 10ms (0,25s) } flow_control_rs232_off(); //Desliga controle de fluxo por hardware da Usart rs232_9600(); //Configura baud Rate p/ 9600 pwm_out_10000(); //Configura frequência do pwm para 10KHz int_timer_1ms_on(); //Liga interrupção 1ms int_count_on(1); //Liga interrupção de estouro de contagem a cada pulsos int_on_rising_edge(); //Liga interrupção de borda de subida int_change_on(); //Liga interrupção de borda de subida F_FF1=0; //INICIA FLAG F_FF2=0; //INICIA FLAG F_FF3=0; //INICIA FLAG F_FF4=0; //INICIA FLAG F_RAMPA=1; //INICIA FLAG // * * * * * * * * * * * * * * * * * * * * * * Loop * * * * * * * * * * * * * * * * * * while(1) { if (F_FF2==1) { F_TESTE=0; write_rs232(0x55); //Envia byte 0x55 delay_100us(20); //Delay múltiplo de 0,1ms (2ms) if(buffer_rs232()!=0) //Há bytes recebidos no buffer? { data=read_rs232(); //Sim, lê byte recebido } else { F_TESTE=1; //Indica erro } rts_on(); //Liga rts delay_100us(2); //Delay múltiplo de 0,1ms (0,2ms) if (cts_in()==0) F_TESTE=1; //Indica erro rts_off(); //desliga rts delay_100us(2); //Delay múltiplo de 0,1ms (0,2ms) if (cts_in()==1) F_TESTE=1; //Indica erro if (F_TESTE==1) buzzer_on(); //Liga buzzer após enviar byte sem erros else buzzer_off(); //Desliga buzzer após enviar byte sem erros } if (button(1)==1) //Botão pressionado? { //Sim if (!F_BOT1) //Já tratou? { //Não, trata F_BOT1=1; //indica que já tratou o botao if (!F_FF1) //Já tratou? { F_FF1=1; //Seta flag led_on(1); //acende led } else {


F_FF1=0; //Limpa flag led_off(1); //Apaga led } buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer } } else { F_BOT1=0; //O botão foi solto, libera para tratar } if (button(2)==1) //Botão pressionado? { //Sim if (!F_BOT2) //Já tratou? { //Não, trata F_BOT2=1; //indica que já tratou o botao if (!F_FF2) //Já tratou? { F_FF2=1; //Seta flag led_on(2); //acende led } else { F_FF2=0; //Limpa flag led_off(2); //Apaga led } buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer } } else { F_BOT2=0; //O botão foi solto, libera para tratar } if (button(3)==1) //Botão pressionado? { //Sim if (!F_BOT3) //Já tratou? { //Não, trata F_BOT3=1; //indica que já tratou o botao if (!F_FF3) //Já tratou? { F_FF3=1; //Seta flag led_on(3); //acende led } else { F_FF3=0; //Limpa flag led_off(3); //Apaga led } buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer } } else { F_BOT3=0; //O botão foi solto, libera para tratar } if (button(4)==1) //Botão pressionado? { //Sim if (!F_BOT4) //Já tratou? { //Não, trata F_BOT4=1; //indica que já tratou o botao if (!F_FF4) //Já tratou? {

40

F_FF4=1; //Seta flag led_on(4); //acende led } else { F_FF4=0; //Limpa flag led_off(4); //Apaga led } buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer } } else { F_BOT4=0; //O botão foi solto, libera para tratar } if (F_FF1==1) digital_out(digital_in());//Lê entradas digitais e copia para as saídas //digitais else testa_analog(); ///testa as analógicas } } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * INTERRUPÇÃO DE TIMER DA APLICAÇÃO * // * - OCORRE A CADA 1mS, O CONTEXTO JÁ FOI SALVO. * // * * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void int_timer_1ms(void) //interrupção de timer de 1ms { //Nesta região devem deve estar o tratamento da interrupção if (++tempo==10) //Contador chegou em 10? { tempo=0; //Sim, inicia o contador if (F_RAMPA==1) //É rampa de subida? { contador++; //sim, incrementa contador de rampa if (contador==200) F_RAMPA=0; } else { contador--; //não, decrementa o contador de rampa if (contador==0) F_RAMPA=1; } pwm_out(1,contador); //Atualiza Pwm 1 com rampa de valor máximo 200 pwm_out(2,contador); //Atualiza Pwm 2 com rampa de valor máximo 200 aux_cont=(contador*50)/200; //Calcula valor de 0 a 50 para escrever na saída analog_out(1,aux_cont); //Atualiza a saída analógica 1 analog_out(2,aux_cont); //Atualiza a saída analógica 2 } } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * INTERRUPÇÃO EXTERNA DA APLICAÇÃO * // * - O CONTEXTO JÁ FOI SALVO. * // * - O FLAG DA INT JÁ FOI LIMPO * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void int_edge(void) //interrupção externa { //Nesta região devem deve estar o tratamento da interrupção buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer


} // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * INTERRUPÇÃO DE MUDANÇA DE ESTADO DA APLICAÇÃO * // * - O CONTEXTO JÁ FOI SALVO. * // * - O FLAG DA INT JÁ FOI LIMPO * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void int_change(void) //interrupção de mudança de estado { //Nesta região devem deve estar o tratamento da interrupção buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * INTERRUPÇÃO DE CONTADOR EXTERNO * // * - O CONTEXTO JÁ FOI SALVO. * // * - O FLAG DA INT JÁ FOI LIMPO * // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void int_count(void) //interrupção de contagem de pulso { //Nesta região devem deve estar o tratamento da interrupção //Na borda de subida do 1º pulso, a interrupção ocorre buzzer_on(); //Liga buzzer delay_10ms(8); //Delay múltiplo de 10ms (80ms) buzzer_off(); //Desliga buzzer }

42

manual do usuário sistema operacional mcdata do usuário - sistema... · manual do usuário –...

Documents