Embed Size (px)
Citation preview
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO – BACHARELADO
PROTÓTIPO DE GRAVADOR DE
MICROCONTROLADORES PIC UTILIZANDO REDES SEM
FIO
JAIR DE SOUZA JUNIOR
BLUMENAU
2012
2012/1-14
JAIR DE SOUZA JUNIOR
PROTÓTIPO DE GRAVADOR DE
MICROCONTROLADORES PIC UTILIZANDO REDES SEM
FIO
Trabalho de Conclusão de Curso submetido à
Universidade Regional de Blumenau para a
obtenção dos créditos na disciplina Trabalho
de Conclusão de Curso II do curso de Ciência
da Computação — Bacharelado.
Prof. Miguel Alexandre Wisintainer - Orientador
BLUMENAU
2012
2012/1-14
PROTÓTIPO DE GRAVADOR DE
MICROCONTROLADORES PIC UTILIZANDO REDES SEM
FIO
Por
JAIR DE SOUZA JUNIOR
Trabalho aprovado para obtenção dos créditos
na disciplina de Trabalho de Conclusão de
Curso II, pela banca examinadora formada
por:
______________________________________________________
Presidente: Prof. Miguel Alexandre Wisintainer – Orientador, FURB
______________________________________________________
Membro: Prof. Antonio Carlos Tavares – FURB
______________________________________________________
Membro: Prof. Francisco Adell Péricas – FURB
Blumenau, 10 de julho de 2012
AGRADECIMENTOS
À minha família, que esteve presente no desenvolvimento deste trabalho.
À Jane, pelo seu carinho e paciência.
Aos meus amigos e colegas, por terem me cobrado e motivado.
Ao meu orientador, Miguel Alexandre Wisintainer, por toda a ajuda e por ter
acreditado na conclusão deste trabalho.
A mente que se abre a uma nova idéia jamais
voltará ao seu tamanho original.
Albert Einsten
RESUMO
Este trabalho apresenta o desenvolvimento de um gravador de microcontroladores utilizando
redes sem fio e a montagem de um protótipo e placa para testes. Na construção do hardware
foram utilizados microcontroladores das famílias PIC24FJ e PIC16F e o módulo de
comunicação sem fio MRF24WB0MA. Foi desenvolvido o software para realizar o pré-
processamento do arquivo para gravação e as rotinas necessárias para a transmissão dos dados
para gravação através do bootloader.
Palavras-chave: Sistemas embarcados. Gravador de microcontroladores. Servidor web.
ABSTRACT
This work presents a microcontroller’s writer development using wireless network,
prototype’s assembly and test plate. For the hardware’s construction were used
microcontrollers families PIC16F and PIC24FJ and communication wireless module
MRF24WB0MA. Was developed the software for preprocessing the file for writing and
routines necessary for the transmission of data recording using a bootloader.
Key-words: Embedded systems. Microcontrollers writers. Web Server.
LISTA DE ILUSTRAÇÕES
Figura 1 - Pinagem do PIC16F877 ....................................................................................... 15
Figura 2 - Pinagem do PIC24FJ256GA106 .......................................................................... 16
Figura 3 - Pinagem do Módulo MRF24WB0MA.................................................................. 19
Figura 4 - Estrutura de um bootloader .................................................................................. 20
Figura 5 - Estrutura de um arquivo Intel Hex........................................................................ 22
Quadro 1 - Exemplo de arquivo .hex .................................................................................... 22
Figura 6 - Interligação dos componentes do Sistema ............................................................ 23
Figura 7 - Arquitetura definida ............................................................................................. 25
Quadro 2 – Características sobre os trabalhos correlatos ....................................................... 25
Figura 8 – Ligação entre os componentes do protótipo ......................................................... 27
Figura 9 – Diagrama esquemático do servidor web embarcado ............................................. 28
Figura 10 – Diagrama esquemático da placa de testes .......................................................... 29
Figura 11 – Diagrama de carregamento do arquivo .............................................................. 31
Figura 12 – Diagrama de montagem dos pacotes .................................................................. 31
Figura 13 – Diagrama para a transmissão dos dados para o servidor ..................................... 32
Figura 14 – Diagrama da função resetUart ..................................................................... 33
Figura 15 – Diagrama da função gravaPIC ....................................................................... 34
Figura 16 – Diagrama da função verificaGravou ......................................................... 35
Figura 17 – Placa do servidor web embarcado artesanal ....................................................... 37
Figura 18 – Placa do servidor web embarcado industrializada .............................................. 38
Figura 19 – Divisor de tensão com resistores ........................................................................ 39
Figura 20 – Divisor de tensão com diodo zenner .................................................................. 39
Figura 21 – Placa de testes ................................................................................................... 40
Quadro 3 – Função para carregamento do arquivo ................................................................ 41
Quadro 4 – Função que realiza a separação dos pacotes ....................................................... 42
Quadro 5 – Função limpaEnderecosHex....................................................................... 42
Quadro 6 – Função getEndereçoLoader....................................................................... 42
Quadro 7 – Função calculaLrc ....................................................................................... 43
Quadro 8 – Função montaUltimoPacote....................................................................... 43
Quadro 9 – Função enviaAjax ......................................................................................... 44
Quadro 10 – Código fonte da rotina FlyportTask ........................................................... 45
Quadro 11 – Código da função resetPic ......................................................................... 46
Quadro 12 – Código da função gravaPic ......................................................................... 47
Quadro 13 – Código da função verificaGravou............................................................ 48
Quadro 14 – Código da função HTTPExecutaGet............................................................ 48
Quadro 15 – Código da função HTTPExecutePost ......................................................... 49
Figura 22 – Ligação entre os hardwares com a placa de testes somente com o bootloader .... 50
Figura 23 – Página inicial ..................................................................................................... 51
Figura 24 – Arquivo carregado com as informações do programa nos campos ..................... 51
Figura 25 – Mensagem apresentada ao usuário no fim do processo ...................................... 52
Figura 26 – Placa de testes executando o programa encaminhado ......................................... 52
Quadro 16 – Característica do protótipo desenvolvido e trabalhos correlatos ........................ 54
Quadro 17 – Código fonte do bootloader utilizado ............................................................... 62
LISTA DE SIGLAS
AJAX – Asynchronous Javascript And XML
DHCP – Dynamic Host Configuration Protocol
HTML – Hyper Text Markup Language
ICSP – In-Circuit Serial Programming
IP – Internet Protocol
LED – Light Emitting Diode
MCLR – Master CLeaR
PIC – Peripheral Interface Controller
TCP – Transmission Control Protocol
TTL – Transistor-Transistor Logic
WPA2 – Wi-Fi Protected Access II
XML – eXtensible Markup Language
SUMÁRIO
1 INTRODUÇÃO ............................................................................................................. 12
1.1 OBJETIVOS DO TRABALHO..................................................................................... 12
1.2 ESTRUTURA DO TRABALHO .................................................................................. 13
2 FUNDAMENTAÇÃO TEÓRICA................................................................................. 14
2.1 MICROCONTROLADORES PIC ................................................................................ 14
2.1.1 Microcontrolador PIC16F877 ..................................................................................... 15
2.1.2 Microcontrolador PIC24FJ256GA106 ......................................................................... 16
2.2 REDES SEM FIO E O PADRÃO 802.11 ...................................................................... 17
2.3 SERVIDORES WEB EMBARCADOS......................................................................... 17
2.4 MÓDULO MICROCHIP MRF24WB0MA ................................................................... 18
2.5 BOOTLOADER ............................................................................................................. 19
2.5.1 Tiny PIC ..................................................................................................................... 20
2.6 OPENPICUS................................................................................................................. 21
2.7 FORMATO INTEL HEX .............................................................................................. 21
2.8 TRABALHOS CORRELATOS .................................................................................... 23
2.8.1 Controle de tráfego ferroviário utilizando PIC16F628A .............................................. 23
2.8.2 O uso da internet e da comunicação sem fio via Zigbee em sistemas embutidos .......... 24
2.8.3 Laboratório de experimentação remota com microcontrolador PIC ............................. 24
2.8.4 Considerações sobre os trabalhos correlatos ................................................................ 25
3 DESENVOLVIMENTO DO PROTÓTIPO ................................................................. 26
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO ..................... 26
3.2 ESPECIFICAÇÃO ........................................................................................................ 26
3.2.1 Visão geral do protótipo .............................................................................................. 27
3.2.2 Hardware .................................................................................................................... 28
3.2.2.1 Diagrama esquemático do servidor web embarcado .................................................. 28
3.2.2.2 Diagrama esquemático da placa de testes .................................................................. 29
3.2.3 Software ..................................................................................................................... 29
3.2.3.1 Especificação do servidor web embarcado ................................................................ 30
3.2.3.1.1 Interface do servidor ............................................................................................ 30
3.2.3.1.2 Rotinas no servidor web ....................................................................................... 32
3.3 IMPLEMENTAÇÃO .................................................................................................... 35
3.3.1 Técnicas e ferramentas utilizadas ................................................................................ 36
3.3.2 Hardware .................................................................................................................... 36
3.3.2.1 Montagem da placa do servidor web embarcado ....................................................... 36
3.3.2.2 Montagem da placa de testes..................................................................................... 38
3.3.3 Software ..................................................................................................................... 40
3.3.3.1 Interface com o Usuário ............................................................................................ 40
3.3.3.2 Servidor web embarcado .......................................................................................... 44
3.3.4 Operacionalidade da implementação ........................................................................... 49
3.4 RESULTADOS E DISCUSSÃO ................................................................................... 53
4 CONCLUSÕES ............................................................................................................. 55
4.1 EXTENSÕES ............................................................................................................... 55
REFERÊNCIAS BIBLIOGRÁFICAS .............................................................................. 57
ANEXO A – Código Fonte do Bootloader ......................................................................... 59
12
1 INTRODUÇÃO
Sistemas embarcados são nos dias de hoje cada vez mais comuns. Existem diversos
aparelhos que contém microcontroladores, desde placares eletrônicos a máquinas industriais
automatizadas (MORIMOTO, 2007). Estes aparelhos podem precisar de atualizações, que
geralmente são efetuadas através da gravação do microcontrolador presencialmente utilizando
a interface serial de um computador.
Microcontroladores estão em evidência no mercado por possibilitar uma infinidade de
aplicações industriais, onde o dispositivo é desenvolvido para uma aplicação específica,
acadêmica, para o aprendizado de eletrônica e programação de dispositivos e até os
―hobbistas‖, que os utilizam somente para lazer.
Silva (2006, p. 28) afirma que ―para se ter uma idéia de sua produção, só na família
16CSX, é de aproximadamente um milhão de unidades semanais‖. Assim verifica-se o
crescimento do mercado de microcontroladores.
Os programas que estão nestes microcontroladores podem sofrer atualizações por
conta de erros no desenvolvimento, configuração de uma determinada característica especial,
incremento de dispositivos ligados ao microcontrolador entre outras. Para que esta atualização
ou troca de programa aconteça é necessário a utilização de um gravador. O microcontrolador
PIC possui alguns dispositivos para efetuar esta gravação, onde o gravador deve estar
conectado ao microcontrolador e a uma interface serial, paralela ou Universal Serial Bus
(USB).
Diante disso, neste trabalho será desenvolvido um protótipo para gravação de
microcontroladores utilizando redes sem fio. Este protótipo utilizará um microcontrolador PIC
e um módulo de conexão sem fio desenvolvido pela Microchip. A utilização deste
equipamento visa facilitar o processo de atualização e ou modificações nos programas que
estão em dispositivos embarcados e podem utilizar a programação através de bootloaders.
1.1 OBJETIVOS DO TRABALHO
O objetivo principal deste trabalho é realizar a tarefa de gravação de
microcontroladores utilizando redes sem fio.
13
Os objetivos específicos do trabalho são:
a) desenvolver o hardware necessário para o protótipo do gravador;
b) desenvolver o hardware necessário para efetuar os testes de gravação;
c) desenvolver um servidor WEB embarcado;
d) desenvolver as rotinas para gravação do microcontrolador através do protocolo de
um bootloader.
1.2 ESTRUTURA DO TRABALHO
Este trabalho está dividido em quatro capítulos. O primeiro traz uma introdução ao
assunto e do que se trata o trabalho. O segundo apresenta uma fundamentação teórica dos
conhecimentos necessários ao desenvolvimento. O terceiro descreve detalhes sobre a
especificação, implementação e testes realizados. O quarto capítulo trata das conclusões e
sugestões para extensões no trabalho.
14
2 FUNDAMENTAÇÃO TEÓRICA
Neste capítulo são apresentados os conceitos necessários ao desenvolvimento deste
trabalho os quais são: microcontroladores PIC, protocolo WI-FI que utiliza o padrão IEEE
802.11, servidores WEB embarcados, módulo MRF24WB0MA, bootloader, Openpicus,
formato Intel Hex e trabalhos correlatos.
2.1 MICROCONTROLADORES PIC
A General Instrument Microelectronics (GI) deu seus primeiros passos fabricando
memórias em 1965 e no início dos anos 70 desenvolveu o microprocessador CP1600. Este
microprocessador trabalhava bem, mas de forma ineficaz no controle de portas de entrada e
saída. Para solucionar este problema, nasceu em 1975 o Peripheral Interface Controller (PIC)
PIC1650, um circuito integrado destinado a controlar portas de entradas e saídas. O PIC
possui uma estrutura muito mais simples que um processador comum e pode manejar as
entradas e saídas com muita facilidade, rapidez e eficiência (SILVA, 2006, p. 28). A empresa
Microchip produz suas famílias de microcontroladores PIC baseados neste modelo inicial
desenvolvido pela GI.
Os microcontroladores PIC operam sobre a arquitetura Harvard, diferentemente da
maioria dos outros microcontroladores que trabalham com a arquitetura Von-Neumann.
Segundo Souza (2002, p. 4), ―a diferença está na forma como os dados e o programa são
processados pelo microcontrolador‖.
Enquanto na arquitetura tradicional existe apenas um barramento interno por onde
passam as instruções e os dados, na arquitetura Harvard existem dois barramentos internos,
sendo um de dados e outro de instruções. Este tipo de arquitetura permite que enquanto uma
instrução é executada outra seja buscada na memória tornando o processamento mais rápido
(SOUZA, 2002, p. 4).
Os microcontroladores PIC utilizam a tecnologia conhecida como Reduced Instruction
Set Computer (RISC). Segundo Silva Junior (1997, p. 3), esta tecnologia ―faz com que
existam poucas instruções (mais ou menos 35, dependendo do modelo) enquanto alguns
microprocessadores tradicionais chegam a ter mais de 100 instruções‖.
15
Existe uma grande variedade de famílias de microcontroladores, dentre elas Microchip
16F, Microchip 18F, Microchip 24F. A escolha da família e do microcontrolador varia
dependendo da aplicação.
2.1.1 Microcontrolador PIC16F877
Microcontrolador de 8 bits da Microchip com memória flash de 8K bytes, pode operar
com freqüências de até 20 MHz e possui 40 pinos (MICROCHIP, 2003a, p. 3). Conforme
Microchip (2003a, p. 3), as principais características deste microcontrolador são (figura 1):
a) 33 pinos de E/S: o desenvolvedor pode selecionar cada pino individualmente
como entrada ou saída de dados;
b) 3 módulos de temporização: módulos que atuam como temporizadores ou
contadores;
c) 8 canais analógicos/digitais: canais que podem ser configurados para atuarem de
forma analógica;
d) 1 canal de comunicação serial: dispõe de canal específico para comunicação
serial;
e) memória flash avançada: permite ao microcontrolador escrever em sua própria
memória de programa;
f) alimentação de 5 volts.
Fonte: Microchip (2003a, p. 3).
Figura 1 - Pinagem do PIC16F877
16
2.1.2 Microcontrolador PIC24FJ256GA106
Microcontrolador de 16 bits da Microchip com memória flash de 256K bytes, pode
operar com freqüências de até 32 MHz e possui 64 pinos (MICROCHIP, 2010b, p. 3).
Conforme Microchip (2010b, p. 4), as principais características deste microcontrolador são
(figura 2):
a) 31 pinos de E/S remapeáveis: o desenvolvedor pode selecionar quais pinos e sua
função como entrada ou saída de dados;
b) 5 módulos de temporização: módulos que atuam como temporizadores ou
contadores;
c) 16 canais analógicos/digitais: canais que podem ser configurados para atuarem de
forma analógica;
d) 4 canal de comunicação serial: dispõe de canal específico para comunicação serial
e) memória flash avançada: permite ao microcontrolador escrever em sua própria
memória de programa;
f) alimentação de 3,3 volts.
Fonte: Microchip (2010b, p. 4).
Figura 2 - Pinagem do PIC24FJ256GA106
17
2.2 REDES SEM FIO E O PADRÃO 802.11
Conforme Alecrim (2008), ―a idéia de conectar computadores através de redes sem fio
não é nova‖. A indústria já se preocupava com esta questão a tempo, mas havia falta de
padronização de normas e especificações. Com isso criou-se a Wireless Ethernet
Compatibility Alliance (WECA) em 1999, que mais tarde viria a se chamar WI-FI Alliance,
em 2003.
O padrão adotado foi o do Institute of Electrical and Electronics Engineers (IEEE)
802.11, que é muito similar ao padrão IEEE 802.3 utilizado pelas redes com fio (ALECRIM,
2008).
A transmissão dos dados é feita através de sinais de radiofreqüência. Como existem
vários dispositivos que geram ou utilizam sinais de rádio é necessário que cada um deles
opere nas freqüências pré-determinadas pelos governos de cada país. Porém, existem algumas
faixas de freqüência que podem ser utilizadas sem concessões de nenhum governo e entre elas
está 2,4 Ghz utilizado popularmente em dispositivos WI-FI (ALECRIM, 2008).
A primeira versão do padrão 802.11 foi publicada em 1997 e foi aprimorada para
permitir compatibilidade entre dispositivos de diversas fabricantes, chegando ao IEEE
802.11g e 802.11n, que estão entre os mais utilizados nos dias atuais.
O 802.11g foi disponibilizado em 2003 e utiliza a técnica de transmissão de dados
Orthogonal Frequency Division Multiplexing (OFDM), onde a informação a ser transmitida é
dividida em pequenos conjuntos de dados que são transferidos simultaneamente em diferentes
freqüências. A velocidade de dados nesta versão é de 54 Mbps (ALECRIM, 2008).
Já o IEEE 802.11n tem como grande diferencial uma nova técnica de transmissão de
dados conhecida como Multiple-Input Multiple-Output (MIMO), possibilitando a transmissão
de dados em várias vias, utilizando mais de um emissor/receptor. Com este recurso a IEEE
802.11n pode chegar a velocidades de transmissão de 300 Mbps (ALECRIM, 2008).
2.3 SERVIDORES WEB EMBARCADOS
Para efetuar um acionamento ou monitoramento remoto, anteriormente aos servidores
WEB embarcados, era utilizado um modelo com um computador e uma placa de aquisição de
18
dados e um driver para comunicação com o microcontrolador (SANTOS, 2009, p. 5).
Neste modelo, é utilizada uma placa específica que se comunica com o computador
através de uma interface serial ou USB, por exemplo. No computador há um servidor WEB
dedicado, o conteúdo a ser acessado através de páginas Hypertext Markup Language
(HTML), que servem como interface para interação com o microcontrolador e os drivers para
comunicação com a placa, na qual está o microcontrolador que realizará as ações solicitadas.
Utilizando este modelo é possível realizar tarefas no microcontrolador, tanto numa rede local
como na internet (SANTOS, 2009, p. 6).
No modelo embarcado, o microcontrolador é que possui um servidor WEB
implementado que se comunica com a aplicação realizando as ações solicitadas. Utilizando a
internet embarcada, não existe mais a necessidade de manter um computador dedicado. As
páginas estão armazenadas no próprio microcontrolador, e o driver não é mais necessário
(SANTOS, 2009, p. 6).
Para que um microcontrolador possa conectar-se à rede, o mesmo deve possuir
interface de rede, controlador ethernet e uma pilha Transfer Control Protocol (TCP)/ Internet
Protocol (IP) desenvolvida especificamente para o microcontrolador (SANTOS, 2009, p.5).
A Microchip disponibiliza uma biblioteca para seu módulo de rede wireless, com a
implementação da pilha TCP/IP, assim como uma biblioteca com os principais protocolos
necessários para a criação de servidores WEB em seus microcontroladores.
2.4 MÓDULO MICROCHIP MRF24WB0MA
Módulo transceptor de radiofreqüência comercializado pela empresa Microchip, que
trabalha na faixa de 2,4 GHz utilizando o padrão IEEE 802.11b/g/n (MICROCHIP, 2010c).
Conforme Microchip (2010c, p. 3) as principais características deste módulo são
(figura3):
a) MAC address único: o endereço físico do módulo é único e seqüencial;
b) alcance de até 400 metros;
c) taxa de transferência de até 2M bytes por segundo;
d) antena integrada;
e) suporte as criptografias WEP, WPA-PSK e WPA-2-PSK;
f) suporte a pilha TCP/IP desenvolvida pela Microchip.
19
Fonte: Microchip (2010c, p. 4).
Figura 3 - Pinagem do Módulo MRF24WB0MA
2.5 BOOTLOADER
Microcontroladores da Microchip com memória flash avançada possuem a capacidade
de escrever em sua memória de programa (MICROCHIP, 2010d). Isto é feito por um
bootloader, ou seja, um programa que está gravado no microcontrolador que permite ler,
escrever e verificar atualizações do programa que estão no microcontrolador através da
interface serial (MICROCHIP, 2010d).
O funcionamento básico do bootloader consiste em um programa que está na memória
de programa do microcontrolador, que ao ser alimentado ou reiniciado, aguarda um
determinado tempo por um sinal específico em sua serial, se este ocorrer, entra em modo de
gravação, leitura ou verificação, senão executa o ultimo programa gravado em sua memória
de programa. A figura 4 ilustra o procedimento.
Existem diversos bootloaders para os microcontroladores PIC da Microchip, entre eles
PICloader, WinPIC, Pic Downloader, mas o escolhido para este trabalho foi o Tiny PIC
devido a seu tamanho reduzido (100 palavras), onerando o menos possível a memória de
programa do microcontrolador a ser programado.
20
Fonte: adaptado de Chiculita (2003).
Figura 4 - Estrutura de um bootloader
2.5.1 Tiny PIC
Tiny PIC é um bootloader criado por Chiculita (2003), com apenas 100 palavras de
programa, sendo um dos menores já criados, suportando microcontroladores PIC das famílias
16F, 18F, dsPIC30.
O Tiny PIC pode escrever a memória flash, eeprom e os bytes de configuração dos
microcontroladores citados. Segundo Chiculita (2003), este projeto surgiu a partir das
seguintes necessidades:
a) os bootloaders utilizados anteriormente continham erros ou não suportavam os
microcontroladores escolhidos;
b) reduzir o tamanho do programa;
c) o bootloader foi criado com a idéia de que o trabalho pesado seria efetuado pela
aplicação no PC, e que o programa no microcontrolador conteria apenas as
funções básicas.
O código fonte do bootloader pode ser visto no anexo A.
21
2.6 OPENPICUS
Openpicus é um projeto criado em janeiro de 2010 na Itália, a partir da idéia de que
estaria em falta no mercado um módulo de fácil programação que tenha suporte não somente
a pilha TCP/IP e wireless da Microchip, mas sim a aplicação completa (OPENPICUS,
2010a). Além disto, o módulo deveria ter baixo custo e permitir o desenvolvimento de
aplicações para o mercado corporativo.
O projeto tem como características principais:
a) o hardware utiliza um microcontrolador PIC da família 24F de 16 bits 64 pinos, e o
módulo wireless MRF24WB0 da Microchip;
b) a alimentação do hardware pode ser com 3.3 ou 5 volts;
c) ambiente de desenvolvimento própria;
d) o ambiente de desenvolvimento permite que o software seja gravado através de um
bootloader diretamente pela porta serial.
O hardware criado para utilização com o ambiente de desenvolvimento foi chamado de
Flyport e é composto por um microcontrolador PIC24FJ256GA106 e o módulo de
comunicação wireless MRF24WB0MA.
2.7 FORMATO INTEL HEX
Segundo Intel (1988, p. 2), ―O formato de arquivo hexadecimal tem como função
representar um arquivo binário absoluto em ASCII‖. Para representar o conteúdo deste
arquivo é necessário que os dados binários sejam convertidos para hexadecimal, por exemplo,
para converter o valor binário de 8 bits 0011111 separa-se inicialmente 0011, 1111 e após
estes valores são convertidos para hexadecimal tendo como resultado final 3F (INTEL, 1988,
p. 2).
Os programas gravados nos microcontroladores PIC geralmente se encontram no
formato Intel Hexadecimal (COX, 2008 p. 1).
O arquivo .hex compreende em um arquivo de texto, em que cada linha corresponde a
um registro e cada um destes é subdividido em um endereço absoluto e uma seqüência de
dados. (COX, 2008 p. 1).
22
Cada linha do arquivo é representada seguindo o padrão indicado na figura 5.
Fonte: Cox (2008, p. 1).
Figura 5 - Estrutura de um arquivo Intel Hex
Para exemplificar um arquivo Intel Hex (quadro 1) segue o conteúdo de um arquivo
.hex com um programa para piscar um led no microcontrolador PIC16F877.
:0A0000001F308A00A02F0000002826
:10000A00831603138801831288010630FB0013301C
:10001A00FC00AD30FD00FD0B1028FC0B1028FB0B7B
:10002A00102800000000013088000630FB00133061
:10003A00FC00AD30FD00FD0B2028FC0B2028FB0B3B
:10004A0020280000000088010630FB001330FC0065
:10005A00AD30FD00FD0B2F28FC0B2F28FB0B2F28A2
:10006A0000000000023088000630FB001330FC005C
:10007A00AD30FD00FD0B3F28FC0B3F28FB0B3F2852
:08008A000000000008284828CE
:02400E004A2F37
:00000001FF
Quadro 1 - Exemplo de arquivo .hex
23
2.8 TRABALHOS CORRELATOS
Nos subitens seguintes, são explanados três trabalhos correlatos desenvolvidos,
apresentados em Sardo (2007), Santana (2008) e Felipe(2010).
2.8.1 Controle de tráfego ferroviário utilizando PIC16F628A
Sardo (2007) apresenta o desenvolvimento de um sistema de controle de malha
ferroviária e a montagem de um protótipo para simulação.
Para a montagem do hardware necessário para o protótipo, Sardo (2007) utilizou um
microcontrolador PIC16F628 com um componente de transmissão de dados TRF-2.4G, nos
trens. Nos cruzamentos foram utilizados o mesmo microcontrolador e componente de
transmissão de dados além dos sensores reed-switch nos trilhos para controle do desvio. O
controlador é o hardware criado para receber as informações do cruzamento e dos trens e
comunicá-lo com o software no computador central.
O software de controle está em um computador central que controla todos os
dispositivos pertencentes a malha ferroviária. Como principal função o software deve
gerenciar a posição de cada trem, evitando possíveis colisões e o posicionamento dos desvios
nos cruzamentos.
Na figura 6 é apresentada a interligação dos componentes no sistema.
Fonte: Sardo (2007, p. 32).
Figura 6 - Interligação dos componentes do Sistema
24
2.8.2 O uso da internet e da comunicação sem fio via Zigbee em sistemas embutidos
Santana (2008) apresenta o desenvolvimento de um sistema embutido que através de
computadores ou aparelhos celulares via internet possa comandar dispositivos e monitorar
sensores em placas remotas via radiofreqüência.
Para o desenvolvimento deste trabalho Santana (2008) conceitua os seguintes temas:
a) Sistemas embutidos, onde considera qualquer atividade que seja executada de
maneira automática por dispositivos eletromecânicos de qualquer natureza;
b) Pilha TCP/IP, que no modelo internet é dividida em 4 camadas, sendo elas
aplicação, transporte, rede e enlace/física;
c) Zigbee, padrão desenvolvido para servir como alternativa de comunicação sem fio
em sistemas não complexos do ponto de vista de implementação da rede de
comunicação.
Santana (2008) utiliza em seu trabalho como servidor WEB o PIC18F2620 e o módulo
ENC28J60 da Microchip para comunicação ethernet. Para comunicação com o módulo
Zigbee é utilizado um PIC18F4550 por trabalhar com a mesma tensão do módulo de
comunicação. Para a comunicação entre os microcontroladores é utilizada comunicação serial.
Na conclusão de seu trabalho Santana (2008) afirma que ―mostrou-se a possibilidade
de realizar o controle de dispositivos eletrônicos pela internet sem a necessidade de usar um
computador como servidor WEB‖.
2.8.3 Laboratório de experimentação remota com microcontrolador PIC
Felipe (2010) apresenta o desenvolvimento de uma arquitetura de um laboratório para
realização de experimentos controlados através da Internet.
No desenvolvimento é apresentado um estudo de caso sobre os sistemas de
experimentação remotas na área de microcontroladores já existentes e suas diferentes
tecnologias. A partir destas idéias Felipe (2010) propôs um sistema que tem como base o uso
de um servidor web embarcado como interface entre o sistema físico e a internet (FELIPE,
2010, p. 7).
A arquitetura proposta no trabalho está ilustrada na Figura 7.
25
Fonte: Felipe (2010, p.59).
Figura 7 - Arquitetura definida
Para o desenvolvimento do trabalho foi utilizado o microcontrolador PIC 18F87J60,
que tem incorporado o módulo que contem a interface para conexão Ethernet.
Felipe (2010) procurou manter o baixo custo e a facilidade de instalação, além de
facilitar o aprendizado das disciplinas de microcontroladores oferecendo um laboratório
remoto para testes.
Na conclusão de seu trabalho Felipe (2010), apresentou o valor gasto (R$202,00) em
componentes para montar uma unidade do laboratório de experimentação remota.
2.8.4 Considerações sobre os trabalhos correlatos
No quadro 2, são apresentadas características sobre os trabalhos de Sardo (2007),
Santana (2008) e Felipe (2010).
Características Sardo (2007) Santana (2008) Felipe (2010)
Comunicação serial X X X
Comunicação via rede cabeada X X
Comunicação Wi-Fi X
Servidor web X X
Gravação de microcontrolador X
Quadro 2 – Características sobre os trabalhos correlatos
26
3 DESENVOLVIMENTO DO PROTÓTIPO
Nas próximas seções são apresentados os requisitos do sistema, a especificação do
hardware e software, a implementação, operacionalidade da implementação, os resultados e
discussão e a conclusão.
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
Os Requisitos Funcionais (RF) e Requisitos Não-Funcionais (RNF) do protótipo são:
a) permitir ao usuário conectar-se ao gravador através de um navegador web (RF);
b) permitir ao usuário carregar um arquivo .hex para o formato de transmissão (RF);
c) permitir ao usuário encaminhar um arquivo formatado para o microcontrolador
(RF);
d) permitir a gravação dos pacotes encaminhados a partir do servidor web (RF);
e) utilizar microcontrolador da família 24F (RNF);
f) utilizar módulo MRF24WB0MA (RNF);
g) utilizar uma placa de testes, para realizar a gravação de um microcontrolador
(RNF);
h) utilizar a linguagem JavaScript (JS) para programação da página hospedada no
servidor web embarcado (RNF);
i) utilizar a linguagem C para a programação dos microcontroladores (RNF).
3.2 ESPECIFICAÇÃO
O protótipo tem como objetivo gravar microcontroladores à distância utilizando redes
sem fio. Para isto, foram montados dois circuitos eletrônicos, o servidor web embarcado e a
placa de testes que contém o microcontrolador a ser gravado remotamente.
Para o servidor web embarcado foram desenvolvidas as rotinas para a comunicação
com o bootloader, respostas do servidor web as requisições get e post e a página hospedada
27
que contém rotinas para a leitura e conversão do arquivo .hex ao padrão necessário para a
transmissão ao microcontrolador.
Para cada dispositivo foi efetuada uma modelagem individual de hardware e de
software. O protótipo está dividido placa de testes e servidor web embarcado, os quais serão
detalhados nas seções adiante.
3.2.1 Visão geral do protótipo
O hardware foi montado de maneira artesanal, apenas sendo necessária a substituição
da placa do servidor web embarcado artesanal por uma de igual esquema desenvolvida pela
empresa Eikon (2010). No circuito montado para a placa de testes, foi utilizado o
microcontrolador PIC16F877A, o qual tem a função de verificar se a gravação foi realizada
corretamente através o bootloader instalado nela utilizando-se um gravador ICSP.
Na figura 8 é ilustrada a ligação entre os componentes do protótipo. O usuário, ao
acessar a página do servidor web embarcado através de uma rede wireless, recebe uma página
com a opção de carregar um arquivo .hex para encaminhá-lo ao servidor. O servidor está
conectado a placa de testes através da interface serial disponibilizada pelos
microcontroladores.
Figura 8 – Ligação entre os componentes do protótipo
28
3.2.2 Hardware
Os diagramas esquemáticos de cada um dos componentes do protótipo estão descritos
nas subseções seguintes. Para a confecção dos diagramas esquemáticos foi utilizada a
ferramenta de desenho e simulação Proteus (JAMESON, 2006).
3.2.2.1 Diagrama esquemático do servidor web embarcado
A placa Flyport, foi desenvolvida como parte do projeto Openpicus (2010), para ser
hardware oficial a ser utilizado com a sua IDE. A placa contém um microcontrolador
PIC24FJ256GA106, responsável por executar a pilha TCP/IP desenvolvida pela Microchip
para a comunicação com o módulo MRF24WB0MA, que possui os recursos de comunicação
wireless 802.11. O projeto por ser opensource, tem em sua página o diagrama esquemático
desta placa, para a montagem. A figura 9 apresenta o diagrama esquemático da placa descrita.
Fonte: adaptado de Openpicus (2012b).
Figura 9 – Diagrama esquemático do servidor web embarcado
29
3.2.2.2 Diagrama esquemático da placa de testes
Para efetuar os testes de gravação e verificação do funcionamento, foi desenvolvida
uma placa que utiliza um microcontrolador PIC16F877A. O microcontrolador está com sua
saída serial conectada a um MAX232 que realiza a conversão de sinais TTL para RS232,
utilizando capacitores carga. As interfaces de entrada e saída RD0 à RD7 estão conectadas
cada uma a um resistor e um LED. No pino Master CLeaR(MCLR) estão conectados um
push-button e o circuito de transistor atuando como chave para possibilitar o reinício da
aplicação para a gravação tanto manual quanto através de um pulso.
O diagrama esquemático da placa é apresentado na figura 10.
Figura 10 – Diagrama esquemático da placa de testes
3.2.3 Software
Nas subseções seguintes são apresentados os diagramas relacionados ao
desenvolvimento do software envolvido no protótipo. Para a especificação do software é
30
utilizado o diagrama de Nassi-Schneiderman com o auxílio da ferramenta Structorizer
(FISCH, 2006).
3.2.3.1 Especificação do servidor web embarcado
O servidor web embarcado é o componente essencial do protótipo, pois nele estão as
rotinas de reinicialização, gravação e verificação do microcontrolador a ser gravado e a
interface ao usuário para envio do arquivo para gravação.
Para o usuário do sistema, ao acessar o servidor web através de um navegador com
suporte a HTML5, é disponibilizada a página inicial, que ao escolher alguma das opções a
ação pode ser local ou no servidor através de requisições get ou post.
3.2.3.1.1 Interface do servidor
A interface interação com o usuário consiste de uma página HTML com a
possibilidade de carregar e encaminhar o arquivo a ser gravado no microcontrolador. A
página contém três funções básicas.
A primeira consiste no carregamento do arquivo que ocorre através de um componente
chamado FileReader. Na figura 11 está representado o diagrama para execução desta função.
A segunda consiste em converter o arquivo carregado no padrão necessário para a
transmissão e gravação no microcontrolador de destino. O padrão escolhido já é o de
utilização do TinyPic (CHICULITA, 2003), que consiste em pacotes de 68 bytes. Estes bytes
estão organizados em endereço de início, que é a posição inicial de endereço de memória do
microcontrolador que ocupa um byte, endereço de fim que é a posição final de endereço de
memória que também ocupa um byte, tamanho do buffer encaminhado, que ocupa um byte, os
dados do programa, que consiste no código hexadecimal gerado através de um montador, que
ocupa sessenta e quatro bytes, e um byte de verificação que neste caso foi utilizada a soma de
todos os sessenta e sete bytes mais complemento de um. A figura 12 representa o diagrama da
função necessária.
31
Figura 11 – Diagrama de carregamento do arquivo
Figura 12 – Diagrama de montagem dos pacotes
32
E a terceira que consiste em chamar a função de reinicialização do microcontrolador e
enviar os pacotes criados na função anterior. Esta função utiliza o componente
XMLHTTPRequest do Javascript. Este componente tem como principal função a troca de
informações entre o navegador e o servidor. Na figura 13 está representado o diagrama
contendo o código para transmissão do arquivo para o servidor.
Figura 13 – Diagrama para a transmissão dos dados para o servidor
3.2.3.1.2 Rotinas no servidor web
O servidor web possui na implementação dos métodos get e post rotinas para a
reinicialização e transferência de dados via interface serial e verificação da gravação.
A primeira rotina é executada através de uma requisição get no servidor de um arquivo
específico. Ao realizar a requisição o servidor chama a função resetUart que através de uma
das interfaces de entrada e saída do microcontrolador aciona o circuito de reinicialização
33
criado na placa de testes. A figura 14 apresenta o digrama contendo o código necessário para
realizar esta operação.
Figura 14 – Diagrama da função resetUart
34
A segunda função é chamada através de uma requisição post no servidor onde é
encaminhado um pacote contendo os dados a serem gravados no microcontrolador. Ao
realizar a postagem no endereço, é encaminhado o pacote a ser gravado no microcontrolador.
O servidor quando recebe o pacote completo, chama a função gravaPic, que através da
interface serial do microcontrolador, encaminha as informações do pacote ao
microcontrolador a ser gravado. Ao fim do envio do pacote, realiza a chamada da função
verificaGravou, que realiza a verificação da resposta do microcontrolador em processo de
gravação.
A figura 15 apresenta o diagrama contendo estrutura necessária para a realização da
função gravaPIC e a figura 16 apresenta o diagrama de estrutura da função verificaGravou.
Figura 15 – Diagrama da função gravaPIC
35
Figura 16 – Diagrama da função verificaGravou
3.3 IMPLEMENTAÇÃO
A seguir é apresentada a implementação, mostrando as técnicas e ferramentas
utilizadas na confecção do hardware e software.
36
3.3.1 Técnicas e ferramentas utilizadas
Para a implementação do hardware foram utilizados os microcontroladores
PIC16F877A para a placa de testes e o PIC24FJ256GA106 juntamente com o módulo
MRF24WB0MA para o servidor web. Para a implementação do servidor web sem fio foi
utilizada a linguagem C com o ambiente de desenvolvimento Openpicus, usando programação
estruturada conforme especificação através dos diagramas de Nassi-Schneiderman. Para
implementação da interface com o usuário foi utilizada a linguagem HTML5 com a
ferramenta Notepad++ (Ho, 2011), usando programação estruturada conforme especificação
através dos diagramas de Nassi-Schneiderman.
3.3.2 Hardware
O hardware corresponde ao servidor web embarcado e placa de testes. Nas subseções
seguintes é apresentada a montagem de cada placa.
3.3.2.1 Montagem da placa do servidor web embarcado
A montagem da placa do servidor web consistiu na reprodução do hardware Flyport
desenvolvido pelo projeto Openpicus (2010), conforme figura 9. Utilizou-se uma placa do
tipo universal para fixação dos componentes.
Na montagem do microcontrolador foi utilizada uma placa adaptadora produzida pela
empresa Cerne Tecnologia (2012), para que o mesmo pudesse ser fixado à placa universal.
Para o componente MRF24WB0MA, não foi encontrada placa adaptadora para fixação à
placa universal, então se optou por uma montagem do componente elevado da placa universal
e seus terminais ligados a placa através de fios.
Como osciladores foram utilizados cristais de 32 MHz para o microcontrolador e
32,768 KHz para o relógio do sistema.
Para a comunicação serial com o bootloader fornecido pelo ambiente de
desenvolvimento foi utilizado o componente ST3232, que possuí a função de converter sinais
TTL (utilizado no microcontrolador) para o padrão RS232 (utilizado no computador).
37
Na figura 17 é apresentado o resultado da montagem do diagrama esquemático.
Figura 17 – Placa do servidor web embarcado artesanal
A placa montada apresentou-se instável, ocasionando mau funcionamento do
microcontrolador. Foram efetuadas novas soldas, troca de componentes, sem sucesso. Durante
as tentativas de carregar algum programa através do bootloader da ferramenta de
desenvolvimento a mesma não reconhecia o modelo do microcontrolador. Devido ao tempo
reduzido para o desenvolvimento do protótipo, optou-se pela substituição da placa construída
artesanalmente por uma de igual diagrama esquemático produzida pela empresa Eikon (2010).
Na figura 18 é apresentada a placa desenvolvida pela empresa Eikon (2010).
38
Figura 18 – Placa do servidor web embarcado industrializada
3.3.2.2 Montagem da placa de testes
A montagem da placa de testes foi efetuada conforme o diagrama esquemático
apresentado na figura 10. Utilizou-se uma placa do tipo universal para fixação dos
componentes.
O microcontrolador PIC16F877A foi montado em um soquete de quarenta pinos para
facilitar a troca do componente se o mesmo sofresse avarias durante os testes do protótipo.
Foi escolhido um cristal oscilador de 4 MHz para gerar o clock necessário ao
microcontrolador.
Para possibilitar a reinicialização do microcontrolador através de um pulso emitido
pelo servidor web embarcado, foi montado um circuito de transistor como chave junto ao pino
Master CLeaR (MCLR).
Nesta placa foi utilizado o componente MAX232 que também tem como função
39
converter sinais TTL para RS232, para assim ser possível realizar os testes de gravação do
microcontrolador através do bootloader disponibilizado por Chiculita (2003). A principal
diferença entre o MAX232 e o ST3232 é sua tensão de trabalho, o primeiro utiliza 5 volts
como alimentação principal e o segundo 3,3 volts.
Para a comunicação serial entre os microcontroladores que utilizam tensões diferentes
de alimentação inicialmente utilizou-se um divisor de tensão com resistores de 20 K ohms e
40 K ohms (figura 19).
Figura 19 – Divisor de tensão com resistores
Durante os primeiros testes com este divisor, constatou-se que a resposta enviada pela
placa de testes continha conteúdo divergente do esperado. Como solução para este problema
foi substituído o divisor com resistores por um divisor com diodo zenner de 3,3 volts e um
resistor de 100 ohms, conforme o diagrama (figura 20).
Figura 20 – Divisor de tensão com diodo zenner
Na figura 21 é apresentada a placa de testes desenvolvida artesanalmente para o
protótipo.
40
Figura 21 – Placa de testes
3.3.3 Software
A implementação do software do servidor web embarcado e da interface com o usuário
é apresentada na subseção seguinte, seguindo a especificação apresentada nas figuras 11 a 16.
3.3.3.1 Interface com o Usuário
A interface com o usuário tem seu código implementado conforme a especificação
apresentada. Inicialmente o arquivo a ser transmitido deve ser carregado através da função
carregaArquivo. A função verifica se o navegador tem suporte ao componente FileReader e
lê o conteúdo do arquivo para a variável. Quando termina a leitura, o método onload do
componente executa a função textoRecebido que chama a função separaPacotes passando
a variável do tipo FileReader como parâmetro.
41
No quadro 3 é apresentada a função para o carregamento do arquivo.
function carregaArquivo() {
var input, file, fr;
tx = [];
if (typeof window.FileReader !== 'function') {
bodyAppend("p", "A API não é suportada neste navegador.");
return;
}
input = document.getElementById('fileinput');
if (!input.files[0]) {
bodyAppend("p", "Por favor, selecione um arquivo!");
}
else {
file = input.files[0];
fr = new FileReader();
fr.onload = textoRecebido;
fr.readAsText(file);
}
function textoRecebido() {
separaPacotes(fr);
}
}
Quadro 3 – Função para carregamento do arquivo
A função separaPacotes (quadro 4), copia o conteúdo do arquivo texto através do
método result para uma variável. Este conteúdo passa primeiramente pela função
limpaEnderecosHex (quadro 5), que retira toda a estrutura de endereços do arquivo Intel
Hexadecimal, e captura os doze primeiros caracteres do arquivo que contém o endereço
inicial do programa a ser gravado e os substitui pelo cabeçalho do bootloader. Estes
caracteres são inseridos no último pacote de gravação no último endereço válido do
microcontrolador antes de todo o conteúdo de gravação do bootloader. Após a remoção dos
endereços, é necessária a remoção das quebras de linha que é efetuada pela função
limpaQuebras.
O conteúdo passa agora pela divisão em pacotes, que são formados por endereço e
tamanho do pacote a ser envidado (6 caracteres), gerados pela função getEnderecoLoader
(quadro 6) unidos a 128 caracteres do conteúdo do arquivo mais a verificação Longitudinal de
Redundância Cíclica, gerado pela função calculaLrc (quadro 7), que contém soma todos os
pares de caracteres do pacote em hexadecimal e aplica complemento de 1.
42
function separaPacotes(fr) {
var result, linha;
result = fr.result;
linha = limpaEnderecosHex(result);
linha = limpaQuebras(linha);
for(i=0; i < linha.length; i+=128){
pacote = getEnderecoLoader()+linha.substr(i, 128);
while(pacote.length != 134){
pacote = pacote + "FF";
}
lrc = calculaLrc(pacote);
tx.push(pacote + lrc + "\r\n");
}
tx.push(montaUltimoPacote());
preencheCampos("textarea", result);
preencheCampos("textarea2", tx.join(""));
endereco = 0;
}
Quadro 4 – Função que realiza a separação dos pacotes
function limpaEnderecosHex(enderecos){
var result;
line = [];
result = limpaQuebras(enderecos);
result = result.split(":");
for(i=1; i < result.length; i++){
if(i == 1){
if( parseInt(result[i].substring(2, 6), 16) < 16128){
cabecalho = result[i].substring(8, 20);
line.push("1F308A00A02F"+result[i].substring(20,
__________________________________result[i].length-2));
line.push("\r\n");
}
}else{
end = parseInt(result[i].substring(2, 6), 16);
if(end < 16128){
line.push(result[i].substring(8, result[i].length-2));
line.push("\r\n");
}
}
}
return line.join("");
}
Quadro 5 – Função limpaEnderecosHex
function getEnderecoLoader(){
end = endereco.toString(16);
while(end.length != 4){
end = "0" + end;
}
incrementaEnderecoLoader();
return end+"40";
}
Quadro 6 – Função getEndereçoLoader
43
function calculaLrc(pacote){
lrc = 0;
for(a=0; a < pacote.length; a+=2){
byte = parseInt(pacote.substr(a, 2), 16);
lrc = (lrc + byte) & 0xFF;
}
lrc = ((( lrc ^ 0xFF) + 1) & 0xFF);
lrc = lrc.toString(16);
if(lrc.length == 1) {
lrc = "0" + lrc;
}
return lrc;
}
Quadro 7 – Função calculaLrc
Os pacotes devem conter tamanho padrão de 134 caracteres. Quando do fim do
conteúdo do arquivo lido, se o pacote não estiver completo, é necessária a inclusão de
caracteres, neste caso FF até o tamanho do pacote. Após a criação do último pacote com os
dados do arquivo é montado o último pacote, deve conter os 12 caracteres capturados na
função limpaEnderecosHex, através da função montaUltimoPacote (quadro 8).
O conteúdo do arquivo lido e os pacotes criados a partir dele, são exibidos no campo
de texto através da função preencheCampos.
function montaUltimoPacote(){
address = "1F8040"
pack = "";
while(pack.length != 112){
pack = pack + "FF";
}
pack = address + pack + "8A01" + cabecalho;
lrc = calculaLrc(pack);
return pack+lrc;
}
Quadro 8 – Função montaUltimoPacote
Para enviar os pacotes ao servidor é utilizado o componente XMLHttpRequest. A
função enviaAjax (quadro 9), faz uma requisição get para o servidor web na página
resetPic.htm passando como parâmetro reset=1. Assim que respondida pelo servidor,
verifica-se o conteúdo da página e se o mesmo for igual a um o microcontrolador está
aguardando o envio dos pacotes.
Os pacotes são encaminhados um a um através de requisições post para o servidor na
página gravaPic.htm passando como parâmetro pacote= mais o conteúdo do pacote. A cada
envio e verificada a resposta do servidor, parando o processo se houver algum erro durante a
execução. Ao final da execução sem erro é apresentada mensagem ao usuário confirmando a
gravação do microcontrolador.
44
function enviaAjax(){
var ajaxRequest = new XMLHttpRequest();
ajaxRequest.open("GET", "resetPic.htm?reset=1", false);
ajaxRequest.send(null);
if(ajaxRequest.responseText != "1"){
alert("Erro ao Resetar o Microcontrolador!");
return;
}else{
for(ab=0; ab < tx.length; ab++){
var queryString = "pacote=" + limpaQuebras(tx[ab]);
ajaxRequest.open("POST", "gravaPic.htm", false);
ajaxRequest.setRequestHeader("Content-type" ,
_____________________________________"application/x-www-form-urlencoded");
ajaxRequest.send(queryString);
if(ajaxRequest.responseText == "0"){
alert("Erro na Verificação da gravação do Pacote!");
return;
}else if(ajaxRequest.responseText == "2"){
alert("Erro na Verificação!");
return;
}
}
alert("Microcontrolador Gravado com Sucesso");
tx = [];
endereco = 0;
cabecalho = "";
}
}
Quadro 9 – Função enviaAjax
3.3.3.2 Servidor web embarcado
O servidor web embarcado contém os dois arquivos principais taskFlyport.c e
HTTPApp.c onde foram implementados os diagramas especificados.
O arquivo taskFlyport.c contém a rotina FlyportTask (quadro 10) que é chamado
pelo programa principal do microcontrolador. A rotina contém as inicializações da interface
serial, do módulo wireless e da saída para reiniciar o microcontrolador.
A função WFConnect é a responsável por configurar o módulo wireless. Suas
configurações são cadastradas através da funcionalidade wizard, disponível no ambiente de
desenvolvimento Openpicus IDE (2010). O módulo foi configurado para conectar a rede sem
fio com nome JJ, na modalidade infra-estrutura utilizando como segurança WPA2 – Pre-
Shared Key Personal.O captura de endereço IP do módulo está configurada para utilizar
DHCP.
45
void FlyportTask()
{
UARTInit(1, 9600);
UARTOn(1);
IOInit(p19, out);
WFConnect(WF_DEFAULT);
while (WFStatus != CONNECTED);
while(1)
{
}
}
Quadro 10 – Código fonte da rotina FlyportTask
Também neste arquivo estão as funções resetPic, responsável pela reinicialização do
microcontrolador que será gravado e inicialização do processo de gravação, gravaPic,
responsável pela transmissão dos pacotes ao microcontrolador e verificaGravou, que efetua
a verificação da gravação no microcontrolador de cada pacote.
A função resetPic (quadro 11) é executada quando uma requisição get é efetuada no
servidor buscando o nome resetPic.htm. Ao ser requisitado, é acionado o pino 19 do
microcontrolador, através do método IOPut por 200 milissegundos. Logo após escreve-se na
interface serial o código binário 11000001, que em hexadecimal representa o valor C1, através
da função UARTWriteCh, aguardado pelo bootloader para iniciar o processo de gravação, o
método tenta encaminhar o valor vinte vezes. Quando o código é recebido com sucesso e o
bootloader devolve o código hexadecimal 1K, representando que o microcontrolador está
pronto para receber os pacotes para a gravação.
A função gravaPic (quadro 12), é executada quando uma requisição post é efetuada
no servidor buscando o arquivo gravaPic.htm, passando o parâmetro pacote com o pacote a
ser encaminhado ao microcontrolador a ser gravado. A função verifica se há alguma
informação no buffer da serial e o limpa. O pacote é dividido em pares de dois caracteres e
convertido de texto para hexadecimal. A função sscanf não converte o hexadecimal 00h,
para isto foi necessário um teste adicional para o caso destes caracteres, em que o valor é
atribuído diretamente. Da mesma forma a função UARTWriteCh também não escreve este
valor, sendo necessária a utilização da função UARTWriteHex, criada especialmente para o
envio desta informação. A cada valor hexadecimal escrito é efetuado uma pausa de um
milissegundo. Após o envio de todos os valores hexadecimais, a função executa a função
verificaGravou.
46
int resetPic()
{
int msglen;
char inmsg[1000];
int a=0;
IOPut(p19, on);
DelayMs(200);
UARTWriteCh(1, 11000001);
IOPut(p19, off);
while(a<20){
msglen = UARTBufferSize(1);
if(msglen > 0){
DelayMs(40);
msglen = UARTBufferSize(1);
UARTRead(1, inmsg, msglen);
inmsg[msglen+1] = '\0';
UARTFlush(1);
if(strstr(inmsg, "1K")!=NULL){
IOPut(o5, off);
return 1;
}
inmsg[0] = '\0';
}
DelayMs(50);
UARTWriteCh(1, 11000001);
a++;
}
return 0;
}
Quadro 11 – Código da função resetPic
Por fim a função verificaGravou (quadro 13), efetua a leitura através da interface
serial informando se o pacote foi gravado com sucesso ou não. Inicialmente verifica-se se
existe resposta do microcontrolador no buffer de comunicação serial, se houver esta é lida
para uma variável. A partir da variável verifica-se se a resposta foi K, se sim a função retorna
o valor 1 e muda de estado o pino 20, senão retorna o valor 0. Se não houver resposta por
parte do microcontrolador em 15 tentativas a função retorna o valor 2.
O arquivo HTTPApp.c, contém as funções relativas aos requisições get e post efetuadas
no servidor.
Quando uma requisição get é efetuada a função HTTPExecuteGet (quadro 14) é
executada antes da devolução da resposta ao arquivo solicitado. A função contém a condição
de se requisitado o arquivo resetPic.htm, executar a função resetPic (quadro 11).
A requisição post, quando recebida pelo servidor, executa a função HTTPExecutePost
(quadro 15). A requisição post é tratada de forma diferenciada, em virtude da possibilidade de
encaminhar mais informações do que o buffer é capaz armazenar, neste caso é feita a leitura
47
do buffer conforme os pacotes forem encaminhados pelo navegador e os dados são
armazenados na variável String_post. Ao finalizar o recebimento das informações, procura-
se o atributo pacote dentro desta variável, retira-se somente o pacote encaminhado pelo
navegador e com este é executada a função gravaPic (quadro 12).
int gravaPic(char* post){
char pacote[69];
memset(pacote, '\0', 69);
char tmp[2];
int b, c=0, d=0;
int retorno=0;
int msglen3;
char inmsg3[50];
msglen3 = UARTBufferSize(1);
if(msglen3 > 0){
msglen3 = UARTBufferSize(1);
UARTRead(1, inmsg3, msglen3);
UARTFlush(1);
}
for(b=0; b < 136; b=b+2){
strncpy(tmp, (post+b), 2);
tmp[2] = '\0';
if(strcmp(tmp, "00") == 0){
char zero[] = { 0x00 };
zero[1] = '\0';
UARTWriteHex(1, zero, 1);
}else{
sscanf(tmp, "%x", &c);
pacote[d] = c;
UARTWriteCh(1, c);
}
DelayMs(1);
d++;
}
pacote[69] = '\0';
DelayMs(300);
retorno = verificaGravou();
return retorno;
}
Quadro 12 – Código da função gravaPic
48
int verificaGravou()
{
int msglen2;
char inmsg2[1000];
int b=0;
while(b<15){
msglen2 = UARTBufferSize(1);
if(msglen2 > 0){
DelayMs(10);
msglen2 = UARTBufferSize(1);
UARTRead(1, inmsg2, msglen2);
inmsg2[msglen2+1] = '\0';
UARTFlush(1);
if(strstr(inmsg2, "K")!=NULL){
IOPut(o5, toggle);
return 1;
}else{
return 0;
}
inmsg2[0] = '\0';
}
DelayMs(50);
b++;
}
return 2;
}
Quadro 13 – Código da função verificaGravou
HTTP_IO_RESULT HTTPExecuteGet(void)
{
BYTE filename[20];
MPFSGetFilename(curHTTP.file, filename, 20);
if(!memcmppgm2ram(filename, "resetPic.htm",12)){
retorno = resetPic();
}
return HTTP_IO_DONE;
}
Quadro 14 – Código da função HTTPExecutaGet
49
HTTP_IO_RESULT HTTPExecutePost(void)
{
BYTE filename[20];
int len;
MPFSGetFilename(curHTTP.file, filename, 20);
while(curHTTP.byteCount)
{
len = TCPFind(sktHTTP, '&', 0, FALSE);
if(len == 0xffff)
{
if( TCPIsGetReady(sktHTTP) == curHTTP.byteCount)
len = curHTTP.byteCount - 1;
else
{
return HTTP_IO_NEED_DATA;
}
}
if (len > HTTP_MAX_DATA_LEN - 2)
{
curHTTP.byteCount -= TCPGetArray(sktHTTP,
______________________________________________(BYTE*)String_post, len+1);
continue;
}
}
if(memcmppgm2ram(String_post,(ROM void*)"pacote", 6) == 0)
{
memcpy(String_post,(void*)&String_post[7], len);
}
grava = gravaPic(String_post);
memset(String_post, '\0', 500);
return HTTP_IO_DONE;
}
Quadro 15 – Código da função HTTPExecutePost
3.3.4 Operacionalidade da implementação
A operacionalidade da implementação inicia com a ligação entre as placas utilizando
cabo específico criado. Em seguida é feita a ligação das fontes do servidor web embarcado e
da placa de testes. A placa de testes contém somente o booloader gravado no
microcontrolador. As saídas estão todas desligadas (figura 22).
Para acessar o servidor é necessário um dispositivo com placa de rede compatível com
o padrão 802.11, para conectar-se ao access point. Assim que conectado, escolhe-se um
navegador compatível com a aplicação e acessa-se o endereço do servidor web (neste caso
http://picus).
50
Figura 22 – Ligação entre os hardwares com a placa de testes somente com o bootloader
A página inicial (figura 23) é exibida, contendo as opções de seleção do arquivo,
carregamento e gravação. Para iniciar o processo de gravação deve-se clicar no botão
Selecionar arquivo. Uma caixa de dialogo é apresentada para a escolha do arquivo .hex.
Após a escolha do arquivo deve-se clicar no botão Carregar Arquivo. Com o
carregamento do arquivo, os campos Arquivo .hex puro e Arquivo .hex com os
pacotes a serem gravados são preenchidos com suas respectivas informações (figura 24).
Em seguida deve-se clicar no botão Gravar, que inicia o envio dos pacotes para o
microcontrolador. Ao iniciar o processo a placa de testes permanece com as saídas todas
apagadas realizando o processo de gravação. Ao finalizar o processo de gravação uma
mensagem é exibida para usuário informando o resultado da operação realizada (figura 25).
O programa gravado no microcontrolador começa a ser executado logo após o término
da gravação. A figura 26 contém a placa de testes executando o programa encaminhado.
51
Figura 23 – Página inicial
Figura 24 – Arquivo carregado com as informações do programa nos campos
52
Figura 25 – Mensagem apresentada ao usuário no fim do processo
Figura 26 – Placa de testes executando o programa encaminhado
53
3.4 RESULTADOS E DISCUSSÃO
O microcontrolador da família 18F escolhido para atuar no servidor web embarcado
teve de ser substituído em função da biblioteca TCP/IP e WI-FI desenvolvidas pela empresa
Microchip terem tamanho incompatível com o disponível pelo microcontrolador.
A utilização do microcontrolador PIC24FJ256GA106 possibilitou o uso do ambiente
Openpicus IDE, que possui um hardware já especificado e facilidade na utilização das
bibliotecas desenvolvidas pela Microchip.
A construção do hardware para o servidor web apresentou problemas quanto a
interferências e oscilações na comunicação com o microcontrolador, alem da falta de
ferramentas adequadas para a soldagem dos componentes principais, por serem mais
sensíveis. Com a substituição do hardware, por um de mesmo diagrama esquemático
industrializado, sanou os problemas com ruído na comunicação entre o microcontrolador e o
ambiente de desenvolvimento através de bootloader. O hardware mostrou-se eficiente para
atuar como servidor web embarcado sem fio.
Na construção do hardware para a placa de testes, a especificação da mesma utilizando
o software de simulação Proteus, possibilitou a compra somente dos componentes necessários
para a montagem da mesma, sem efetuar gastos desnecessários. O microcontrolador escolhido
para a placa de testes se mostrou estável e com baixo nível de ruído, trabalhando a freqüência
de 4 MHz. Para a gravação do bootloader no microcontrolador foi construído um gravador de
microcontroladores serial.
A comunicação serial entre os microcontroladores apresentou dificuldades quanto a
diferença de alimentação utilizada. Inicialmente a escolha de um divisor de tensão com
resistores solucionou o problema de diferença de tensão. Ao iniciar os testes de reinicialização
da placa de testes, a resposta ao servidor WEB possuía o conteúdo esperado, mas ao transmitir
um pacote para gravação não. Foram substituídos os resistores por outros valores e o
problema persistia. Substituir o divisor com resistores por divisor com diodo zener mostrou-se
como solução após a conexão de um ST3232 no local do divisor para verificar a resposta da
placa de testes onde se verificou resposta correta quando do componente conectado.
Através de medições com o multímetro, verificou-se que a tensão após o divisor
enquanto o microcontrolador estava recebendo o conteúdo encaminhado pela placa do
servidor web era em torno de 0,8 volts e após a ligação do ST3232 a tensão era de 1,7 volts.
Assim verificou-se que o divisor estava reduzindo a tensão de saída do microcontrolador
54
prejudicando a comunicação.
Quanto à implementação do servidor WEB a ferramenta utilizada para a programação
facilitou o desenvolvimento por abstrair toda a parte de estrutura das camadas do protocolo
TCP/IP e 802.11, sendo necessária preocupação com o tratamento das informações recebidas
do navegador e comunicação com a placa de testes.
Na implementação da página residente no microcontrolador, a principal preocupação
era transferir o máximo de processamento para o navegador, deixando o servidor WEB
apenas com a tarefa de comunicação. A utilização do componente para leitura de arquivos
locais no navegador possibilita que o pré-processamento do arquivo hexadecimal seja
realizado diretamente no navegador já o deixando no formato necessário para gravação na
placa de testes. Programar o dispositivo a cada pacote encaminhado gerou vantagem por não
onerar a memória do microcontrolador com as informações para gravação da placa de testes.
Foram realizados testes de gravação do microcontrolador através de rede local,
wireless e internet utilizando computadores e um celular.
Exceto pelos problemas citados, as funcionalidades esperadas do protótipo
desenvolvido foram alcançadas.
No quadro 16 é apresentado o comparativo das características do protótipo
desenvolvido com os trabalhos correlatos.
Características Felipe (2010) Sardo (2007) Santana
(2008) Souza (2012)
Comunicação Serial X X X X
Comunicação via Rede X X
Comunicação Wi-Fi X X
Servidor web X X X
Gravação de
Microcontrolador X X
Utilização de bootloader X
Gravação através de
requisições AJAX X
Quadro 16 – Característica do protótipo desenvolvido e trabalhos correlatos
55
4 CONCLUSÕES
Desenvolver um protótipo de gravador de microcontroladores sem fio foi considerado
um trabalho com relevância, pois envolveu montagem de hardware, comunicação entre
dispositivos e desenvolvimento de software em duas linguagens distintas.
Os objetivos de desenvolver o hardware necessário para efetuar os testes de gravação,
criar as rotinas para gravação do microcontrolador através de um bootloader e montagem de
um servidor web embarcado foram alcançados. Quanto ao objetivo de desenvolver o hardware
necessário para o protótipo do gravador, foi atendido parcialmente, pois foi efetuada a
construção do hardware especificado, mas sem sucesso em virtude de problemas com a
comunicação do microcontrolador com o ambiente de desenvolvimento. Com o tempo
reduzido disponível para conclusão do protótipo, optou-se pela aquisição deste hardware para
atendimento dos demais objetivos.
O hardware do servidor web mostrou-se adequado as necessidades do protótipo,
podendo ser expandido como meio de comunicação com o hardware a ele conectado por
possuir mais interfaces seriais. A placa de testes também mostrou-se adequada as
necessidades para a realização dos testes de gravação e demonstração da aplicação.
A possibilidade de se gravar um microcontrolador utilizando a rede local ou internet
através de um computador ou celular gera facilidade na atualização ou manutenção de
equipamentos microcontrolados e reduzindo a necessidade de deslocamento e manuseio do
equipamento nestas intervenções.
No entanto existem limitações no trabalho desenvolvido. O servidor web possui
configuração de sua interface de rede estática e adequação as necessidades apenas para a
gravação do microcontrolador PIC16F877A.
4.1 EXTENSÕES
Existem pontos que podem ser agregados ou melhorados no protótipo. Como sugestão
pode-se citar:
a) desenvolver uma página para a configuração da interface de rede do servidor web;
b) desenvolver uma página para a configuração dos microcontrolador utilizado;
56
c) possibilitar a atualização do servidor web através de autogravação do
microcontrolador;
d) desenvolver um montador para possibilitar ao usuário programar diretamente no
navegador sem a necessidade de software específico;
e) desenvolver um hardware com menor custo para o servidor web sem fio.
57
REFERÊNCIAS BIBLIOGRÁFICAS
ALECRIM, Emerson. Tecnologia WI-FI (IEEE 802.11). [S.l.], 2008. Disponível em:
<http://www.infowester.com/wifi.php>. Acesso em: 05 set. 2011.
CERNE, Teconologia. Conversor TQFP64-DIP. [S.l.], 2012. Diponível em:
<http://www.cerne-tec.com.br/escolheconversor.htm>. Acesso em: 15 abr. 2012.
CHICULITA, Claudiu. Tiny Pic bootloader. Romênia, 2003. Disponível em
<http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm>. Acesso em: 15 fev. 2012.
COX, Fred J. Formato Intel hex usado em microcontroladores. [S.l.] 2008. Disponível em
<http://www2.eletronica.org/Members/fredcox/Formato_Intel_Hex_Microcontroladores.pdf>.
Acesso em: 15 fev. 2012.
EIKON. Flyport Wi-Fi PCB Antenna. Itália, 2010. Disponível em:
<http://www.eikonsite.it/products/openpicus+picus+flyport+wifi+module/FLYPORT+Wi-
Fi+PCB+Antenna.aspx>. Acesso em: 05 mar. 2012.
FELIPE, Ágio G. M. Laboratório de experimentação remota com o microcontrolador
PIC. 2010. 109 f. Dissertação (Mestrado Profissional em Computação Aplicada) -
Universidade Estadual do Ceará e Instituto Federal de Educação, Ciência e Tecnologia do
Ceará, Fortaleza.
FISCH, Bob. Strutorizer. [S.l.], 2012. Disponível em: <http://structorizer.fisch.lu>. Acesso
em: 05 abr. 2012.
INTEL. Hexadecimal object file format specification. [S.l.], 1988. Disponível em:
<http://microsym.com/editor/assets/intelhex.pdf>. Acesso em: 15 fev. 2012.
JAMESON, John. Proteus. Inglaterra, 2006. Disponível em: <http://www.labcenter.co.uk>.
Acesso em: 23 out. 2011.
HO, Don. Notepad++. [S.l.], 2011. Disponível em: <http://notepad-plus-plus.org>. Acesso
em: 23 fev. 2012.
MICROCHIP. Microchip PIC16F87XA. [S.l.], 2003a. Disponível em:
<http://ww1.microchip.com/downloads/en/DeviceDoc/39582b.pdf >. Acesso em: 15 fev.
2012.
______. Microchip PIC24FJ256GA110 Family. [S.l.], 2010b. Disponível em:
<http://ww1.microchip.com/downloads/en/DeviceDoc/39905e.pdf>. Acesso em: 05 mar.
2012.
58
______. Microchip MRF24WB0MA/MRF24WB0MB. [S.l.], 2010c. Disponível em:
<http://ww1.microchip.com/downloads/en/DeviceDoc/39905e.pdf>. Acesso em: 15 fev.
2012.
______. AN1310: high-speed serial bootloader for pic16 and pic18 devices . [S.l], 2010d.
Disponível em: <http://ww1.microchip.com/downloads/en/AppNotes/01310a.pdf>. Acesso
em: 15 fev. 2012.
MORIMOTO, Carlos E. Hardware: o guia definitivo. Porto Alegre, 2007. Disponível em:
<http://www.hardware.com.br/livros/hardware/sistemas-embarcados.html>. Acesso em: 3
ago. 2011.
OPENPICUS. Openpicus presentation: press release. Itália, 2010a. Disponível em:
<http://openpicus.blogspot.com.br/2010/03/openpicus-presentation-press-release.html>.
Acesso em: 05 mar 2012.
______. Flyport WIFI Ver 3 schematic. Itália, 2012b. Disponível em:
<http://space.openpicus.com/u/ftp/Flyport%20WiFi/33_SCH_flyport_wifi.pdf>. Acesso em:
05 mar. 2012.
SANTANA, Lucas V. O uso da internet e da comunicação sem fio via zigbee em sistemas
embutidos. 2008. 89 f. Trabalho de Conclusão de Curso (Graduação de Engenharia de
Controle e Automação) – Universidade Federal de Ouro Preto, Ouro Preto.
SANTOS, Johnny C. M. Projeto de um sistema microcontrolado utilizando internet
embarcada para monitoramento remoto em tempo real de temperatura e
disponibilização dos dados na web através de conexão de rede. 2009. 174 f. Trabalho de
Conclusão de Curso (Graduação em Engenharia de Computação) – Universidade Federal do
Rio Grande do Norte, Natal.
SARDO, Andrey S. Controle de tráfego ferroviário utilizando microcontrolador
PIC16F628A. 2007. 68 f. Trabalho de Conclusão de Curso (Graduação em Ciências da
Computação) – Universidade Regional de Blumenau, Blumenau.
SILVA, Renato A. Programando microcontroladores PIC: linguagem C. São Paulo:
Ensino Profissional, 2006.
SILVA JÚNIOR, Vidal P. Microcontroladores PIC: teoria e prática. São Paulo, 1997.
SOUZA, David J. Desbravando o PIC. 5. ed. São Paulo: Érica, 2002.
59
ANEXO A – Código Fonte do Bootloader
O bootloader utilizado no microcontrolador PIC16F877A desenvolvido por Chiculita
(2003) tem o código fonte escrito na linguagem assembly. O quadro 15 contém o código fonte
do bootloader.
radix DEC
LIST P=16F877A, F=INHX8M ;
xtal EQU 4000000
baud EQU 9600
;********************************************************************
; Tiny Bootloader 16FxxxA series Size=100words
; http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm
;********************************************************************
#include "../icdpictypes.inc"
#include "../spbrgselect.inc"
#include "../bankswitch.inc"
#define first_address max_flash-100 ; 100 word in size
__CONFIG _HS_OSC & _CP_OFF & _WDT_OFF & _BODEN_ON & _PWRTE_ON &
_LVP_OFF & _DEBUG_OFF
errorlevel 1, -305 ; suppress warning msg that takes f as default
cblock 0x20
buffer:80
endc
cblock 0x78
crc
contor
i
cnt1
cnt2
cnt3
flag
endc
SendL macro car
movlw car
movwf TXREG
endm
;0000000000000000000000000 RESET 00000000000000000000000000
ORG 0x0000
PAGESEL IntrareBootloader
GOTO IntrareBootloader
;view with TabSize=4
;&&&&&&&&&&&&&&&&&&&&&&& START &&&&&&&&&&&&&&&&&
;---------------------- Bootloader ----------------------
;
;
60
;PC_flash: C1h AddrH AddrL nr ...(DataLo DataHi)... crc
;PIC_response: id K K
ORG first_address
nop
nop
nop
nop
org first_address+4
IntrareBootloader
;init serial port
clrf STATUS
bsf STATUS,RP0 ;BANK1_
movlw b'00100100'
movwf TXSTA
movlw spbrg_value
movwf SPBRG
BANK0_
movlw b'10010000'
movwf RCSTA
;wait for computer
call Receive
sublw 0xC1 ;Expect C1
skpz
goto way_to_exit
SendL IdTypePIC ;PIC type
;SendL IdSoftVer ;firmware ver x
MainLoop
clrf STATUS ;bank0
SendL 'K'
mainl
clrf crc
call Receive ;H
bsf STATUS,RP1 ;bank2
movwf EEADRH
movwf flag ;used to detect if is eeprom
call Receive ;L
bsf STATUS,RP1 ;bank2
movwf EEADR
call Receive ;count
movwf contor
movwf i
incf i
movlw buffer-1
movwf FSR
rcvoct
call Receive
incf FSR
movwf INDF
decfsz i
goto rcvoct
movf crc,f ;check checksum
skpz
goto ziieroare
;write
bsf STATUS,RP1 ;bank switch 0->2
movlw buffer
movwf FSR
writeloop ; write 2 bytes = 1 instruction
61
clrwdt
movf INDF,w
movwf EEDATA
incf FSR
movf INDF,w
movwf EEDATH
incf FSR
BANK3_ ;bank 2->3
bcf EECON1,EEPGD
btfss flag,6 ;is eeprom (or flash)
bsf EECON1,EEPGD
bsf EECON1,WREN
movlw 0x55
movwf EECON2
movlw 0xaa
movwf EECON2
bsf EECON1,WR
nop
nop
waitwre
btfsc EECON1,WR ;for eeprom writes (wait to finish
write)
goto waitwre
bcf EECON1,WREN
BANK2_ ;bank2
incf EEADR ;does not cross zones
btfss flag,6 ; if writing to EEPROM, skip
first counter dec.
decf contor
decfsz contor
goto writeloop
goto MainLoop
ziieroare
SendL crc
goto mainl
Receive
clrf STATUS
movlw xtal/2000000+1 ; for 20MHz => 11 => 1second
movwf cnt1
rpt2
clrf cnt2
rpt3
clrf cnt3
rptc
btfss PIR1,RCIF ;test RX
goto $+4
movf RCREG,w ;return in W
addwf crc,f ;compute checksum
return
clrwdt
decfsz cnt3
goto rptc
decfsz cnt2
goto rpt3
decfsz cnt1
goto rpt2
;timeout:
way_to_exit ;exit in all other cases; must be BANK0/1
62
;BANK0_
bcf RCSTA, SPEN ; deactivate UART
goto first_address
;*************************************************************
; After reset
; Do not expect the memory to be zero,
; Do not expect registers to be initialised like in catalog.
END
Quadro 17 – Código fonte do bootloader utilizado
![Gravador Pic 16f 268[1]](https://img.document.onl/doc/110x75/5571fd43497959916998b966/gravador-pic-16f-2681.jpg)
![Apostila de Microcontroladores PIC e Perifericos[Www.mecatronicadegaragem.blogspot.com]](https://img.document.onl/doc/110x75/557213c1497959fc0b92f189/apostila-de-microcontroladores-pic-e-perifericoswwwmecatronicadegaragemblogspotcom-55cac1bb1ea4b.jpg)
![Apostila de Microcontroladores PIC e Perifericos[]](https://img.document.onl/doc/110x75/5571fa2f497959916991808a/apostila-de-microcontroladores-pic-e-perifericoswwwmecatronicadegaragemblogspotcom.jpg)
![Microcontroladores PIC Para Iniciantes [Poluidor.blogspot.com]](https://img.document.onl/doc/110x75/5572143c497959fc0b941310/microcontroladores-pic-para-iniciantes-poluidorblogspotcom.jpg)
