MATHEUS DANIEL FACCIN
DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE
COMUNICAÇÃO PADRÃO USB COM
MICROCONTROLADOR ARM.
Londrina 2016
MATHEUS DANIEL FACCIN
DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE
COMUNICAÇÃO PADRÃO USB COM
MICROCONTROLADOR ARM.
Trabalho de Conclusão de Curso apresentado ao Departamento de Engenharia Elétrica da Universidade Estadual de Londrina, como requisito parcial à obtenção do título de Bacharel em Engenharia Elétrica. Orientador: Prof. Dr. Leonimer Flávio de Melo
Londrina 2016
Matheus Daniel Faccin
DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE COMUNICAÇÃO
PADRÃO USB COM MICROCONTROLADOR ARM. -Londrina, 2016 - 82 p., 30cm
Orientador: Prof. Dr. Leonimer Flávio de Melo
1. Programação. 2. Comunicação USB. 3. Interface humana
I. Universidade Estadual de Londrina. Curso de Engenharia Elétrica. II.
DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE COMUNICAÇÃO
PADRÃO USB COM MICROCONTROLADOR ARM
MATHEUS DANIEL FACCIN
DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE
COMUNICAÇÃO PADRÃO USB COM
MICROCONTROLADOR ARM.
Trabalho de Conclusão de Curso apresentado ao Departamento de Engenharia Elétrica da Universidade Estadual de Londrina, como requisito parcial à obtenção do título de Bacharel em Engenharia Elétrica.
BANCA EXAMINADORA
____________________________________ Orientador: Prof. Dr. Leonimer Flávio de Melo
Universidade Estadual de Londrina - UEL
____________________________________ Prof. Dr. Aziz Elias Demian Junior
Universidade Estadual de Londrina - UEL
____________________________________ Prof. Dr. Newton da Silva
Universidade Estadual de Londrina - UEL
Londrina, 22 de janeiro de 2016.
AGRADECIMENTO (S)
Agradeço a Deus por ter me dado a oportunidade e permitiu que
tudo isso acontecesse.
Aos meus pais e família, pelo apoio e confiança durante toda minha
vida.
A esta universidade e todos os professores que se dedicaram a
educação durante minha formação, e ao meu orientador, prof. Dr. Leonimer Flávio
de Melo, por orientações a esse trabalho.
Agradeço a meus amigos pelas horas que passamos junto.
Faccin, Matheus D. Desenvolvimento de um sistema embarcado de comunicação padrão usb com microcontrolador arm. 2015. (NUMERO DE PAGINAS). Trabalho de Conclusão de Curso (Graduação em Engenharia Elétrica) – Universidade Estadual de Londrina, Londrina, 2015.
RESUMO
Neste trabalho é demonstrado o estudo e desenvolvimento de um firmware
customizado para sistema embarcado com microcontrolador ARM, que o torna
capaz de utilizar a tecnologia de comunicação USB On-The-Go para controle de um
periférico USB da classe interface humana, contendo a capacidade de interpretar um
teclado USB. Todos os caracteres ABNT2 e as funções de digitação existentes no
teclado estão entre os recursos presentes no programa. A exibição resultante da
digitação do texto ocorre por meio de imagens e caracteres em um display LCD
disponível na placa do microcontrolador. O desafio proposto a este projeto, foi
produzir o código de forma que ele possa ser facilmente utilizado em outros projetos
futuros, para isso, foi utilizado uma interface gratuita a CoIDE e foi escrito em todas
as principais funções e rotinas, comentários e instruções para uso prático, assim
agilizando a compreenção do código.
Palavras-chave: USB. OTG. Teclado. ARM cortex. CoIDE.
Faccin, Matheus D. Development of embedded system on USB standard communication with ARM microcontroller. 2015. (NUMERO DE PAGINAS). Trabalho de Conclusão de Curso (Graduação em Engenharia Elétrica) – Universidade Estadual de Londrina, Londrina, 2015.
ABSTRACT
This work demonstrates the study and development of a custom firmware for
embedded system with ARM microcontroller, which makes it able to use the USB
communication technology USB On-The-Go to host a USB in human interface device
class, having the ability to understand a USB keyboard. All ABNT2 existing
characters and typing function on the keyboard are among the features in the
program. The resulting display of text typing occurs through images and characters
on an LCD display available on the microcontroller board. The challenge posed for
this project was to produce the code so that it can be easily used in other future
projects, for it was written in all major functions and routines, comments and
instructions for practical use, thus speeding the comprehension of code.
Key words: USB. OTG. Keyboard ARM cortex. Stm32f429.CoIDE
LISTA DE ILUSTRAÇÕES
Figura 2.1 – Cartão perfurado com linguagem de programação Fortran ................. 23
Figura 2.2 – Máquina de perfurar Cartão ................................................................ 24
Figura 2.3 – Instalação automática de driver ........................................................... 25
Figura 2.4 – Conector USB e seu símbolo .............................................................. 27
Figura 2.5 – Modelos de conectores USB ............................................................... 28
Figura 2.6 – Exemplos de conexões para dispositivos OTG ................................... 29
Figura 2.7 – Detalhe conector USB micro-A e micro-B ........................................... 30
Figura 2.8 – Diagrama da conexão entre dispositivos ............................................. 30
Figura 2.9 – Cabo USB OTG ................................................................................... 31
Figura 2.10 – Transferências de pacotes ................................................................ 33
Figura 2.11 – Estrutura dos descritores de dispositivo ............................................ 35
Figura 2.12 – Matrizes de contatos do teclado ........................................................ 37
Figura 3.1 – Diagrama descritivo ............................................................................. 41
Figura 4.1 – STM32F429 componentes frente ........................................................ 44
Figura 4.2 – STM32F429 componentes atrás ......................................................... 45
Figura 4.3 – Teclado USB utilizado ......................................................................... 47
Figura 5.1 – CoIDE .................................................................................................. 49
Figura 5.2 – Estrutura CMSIS .................................................................................. 50
Figura 5.3 – Interface para controle de frequência STM32Cube ............................. 51
Figura 5.4 – Interface para controle dos pinos STM32Cube ................................... 53
Figura 5.5 – Representação de caractere em pixel na tela ..................................... 55
Figura 5.6 – Organização dos conjuntos de bibliotecas USB .................................. 56
Figura 5.7 – Organização dos conjuntos de bibliotecas USB host .......................... 58
Figura 5.8 – Diagrama da função USBH_process ................................................... 60
Figura 5.9 – Diagrama das rotinas do projeto.......................................................... 64
Figura 6.1 – Verificação de erros CoIDE ................................................................. 67
Figura 6.2 – Reconhecimento do teclado USB ........................................................ 68
Figura 6.3 – Digitação na placa ............................................................................... 69
Figura 6.4 – Exemplo de código .............................................................................. 70
LISTA DE TABELAS
Tabela 2.1 – Padrão dos fios de um cabo USB ....................................................... 32
Tabela 2.2 – Token Packet ...................................................................................... 33
Tabela 2.3 – Pacote de dados ................................................................................. 34
Tabela 2.4 – Pacote de confirmação ....................................................................... 34
Tabela 2.5 – Estrutura da informação recibida do teclado ....................................... 39
LISTA DE ABREVIATURAS E SIGLAS
ABNT Associação Brasileira de Normas Técnicas
ASCII American Standard Code for Information Interchange
ARM Advanced RISC Machine
CMSIS Cortex Microcontroller Software Interface Standard
HID Humam interface device
LDC liquid crystal display
OTG On The Go
PC Personal computer
PLL Phase-locked loop
TFT Thin-film transistor
USB Universal Serial Bus
SUMÁRIO
1 INTRODUÇÃO .......................................................................................... 19
1.1 DESCRIÇÃO DO PROJETO ............................................................................. 19
1.2 OBJETIVOS .................................................................................................. 19
1.2.1 Objetivo Específicos .................................................................................. 20
1.3 JUSTIFICATIVA ............................................................................................. 20
1.4 DESCRIÇÃO DOS CAPÍTULOS ......................................................................... 21
2 REVISÃO BIBLIOGRÁFICA ..................................................................... 23
2.1 DISPOSITIVO DE INTERFACE ......................................................................... 23
2.1.1 Cartões Perfurados ................................................................................... 23
2.1.2 Surgimento do Teclado ............................................................................. 24
2.1.3 Driver de Dispositivo ................................................................................. 25
2.2 LINGUAGENS DE PROGRAMAÇÃO ................................................................... 25
2.2.1 Programação EM C .................................................................................... 25
2.3 ASCII ......................................................................................................... 26
2.4 USB ......................................................................................................... 27
2.4.1 Conectores ................................................................................................ 27
2.4.2 On-The-Go ................................................................................................ 28
2.4.3 Taxa de Transmissão ................................................................................ 31
2.4.4 Cabo USB ................................................................................................. 31
2.4.5 Protocolo de Comunicação ....................................................................... 32
2.4.6 Classes de Dispositivos USB .................................................................... 36
2.5 TECLADO .................................................................................................... 37
2.5.1 Padrões de Conectores ............................................................................. 38
2.5.2 Formato de envio das informações ........................................................... 38
3 DESCRIÇÃO DO PROJETO .................................................................... 41
3.1 DIAGRAMA DESCRITIVO ................................................................................ 41
3.2 TECLADO USB ............................................................................................ 41
3.3 CABO ADAPTADOR USB OTG ...................................................................... 41
3.4 MICROCONTROLADOR ARM ......................................................................... 42
3.5 SOFTWARE .................................................................................................. 42
3.6 DISPLAY TFT LCD ...................................................................................... 42
4 DESCRIÇÃO DO HARDWARE EMBARCADO........................................ 43
4.1 STM32F429 ................................................................................................ 43
4.1.1 Processador Cortex-M4 ............................................................................ 45
4.1.2 Interfaces USB Presente no stm32f429 .................................................... 46
4.1.3 Alimentação do Stm32f429 ....................................................................... 46
4.2 TECLADO USB ............................................................................................ 46
5 DESCRIÇÃO DO FIRMWARE .................................................................. 49
5.1 INTERFACE DE DESENVOLVIMENTO ................................................................ 49
5.1.1 COIDE ....................................................................................................... 49
5.2 BIBLIOTECAS ............................................................................................... 50
5.2.1 CMSIS ....................................................................................................... 50
5.2.2 STM32Cube .............................................................................................. 52
5.2.3 Tela Sensível ao Toque ............................................................................ 54
5.2.4 Impressão de Caracteres .......................................................................... 54
5.2.5 USB ......................................................................................................... 56
5.3 PRINCIPAIS FUNÇÕES ................................................................................... 59
5.4 PROCEDIMENTO........................................................................................... 62
5.4.1 Pré-requisitos ............................................................................................ 62
5.4.2 Início do Projeto ........................................................................................ 60
5.4.3 Implementações ........................................................................................ 60
6 RESULTADOS OBTIDOS ........................................................................ 67
6.1 VERIFICAÇÃO DE ERROS ............................................................................... 67
6.2 FUNCIONAMENTO ......................................................................................... 67
6.3 PROGRAMA ................................................................................................. 70
7 CONCLUSÃO ........................................................................................... 71
REFERÊNCIAS......................................................................................... 73
APÊNDICE A ............................................................................................ 75
ANEXO A .................................................................................................. 79
19
1 INTRODUÇÃO
Microcontroladores possuem muitas utilidades e o crescimento dos
sistemas embarcados tem os tornado muito frequentes devido suas vantagens, de
serem pequenos, baratos e o baixo consumo de energia. Com o aumento de sua
capacidade de processamento, alguns podem ter mais de uma função, e até mesmo
capaz de serem alteradas durante o uso e com isso vem a necessidade de
comunicação entre sistemas embarcados e os utilizadores, assim possibilitando
também um diagnóstico, monitoramento visual ou transferência de dados
armazenados. A comunicação deve ser feita de forma simples ao usuário e
disponível em vários tipos de equipamento. O trabalho de desenvolvimento de um
sistema de comunicação USB com microcontroladores pretende fornece
interatividade em projetos desenvolvidos, em desenvolvimento ou em planejamento,
pois pode ser adicionado a qualquer momento em outros programas. Estão
presentes nesse software as configurações necessárias para fornecer comunicação
teclado USB. Grande parte desse projeto são as biblioteca de funções para
comunicação USB que proporciona em sua utilização facilidade de configuração e
instruções de uso no desenvolvimento de um sistema personalizado ou de outras
funcionalidades caso seja necessário.
1.1 DESCRIÇÃO DO PROJETO
O projeto é a programação da comunicação do teclado USB ABNT2
com um microcontrolador stm32f429 da família ARM cortex M4. Com a possibilidade
de se imprimir caracteres no display TFT LCD juntamente com um pequeno editor de
texto. Sua criação em ambientes de desenvolvimentos gratuitos e em código aberto
para fácil reaproveitamento de seu conteúdo ou parte dele em ambiente acadêmico.
1.2 OBJETIVO GERAL
O objetivo desse trabalho é realizar a comunicação de um
microcontrolador ARM com um teclado por meio do padrão USB.
20
1.2.1 Objetivo Específicos
Programação de forma organizada e reaproveitável de um projeto
que faça a inicialização em um microcontrolador ARM Cortex M4 na placa
stm32f429, reconhecimento pelo microcontrolador de qualquer teclado USB de
forma pronto pra uso, exibição gráfica em uma tela TFT LCD e utilização dos
caracteres no padrão ABNT2.
1.3 JUSTIFICATIVA
A realização de um projeto com microcontroladores pode envolver a
reutilização de diversas bibliotecas, geralmente no mínimo se utiliza as feitas pelo
fabricante para inicializar a placa, para microcontrolador da família córtex-M existe
as bibliotecas CMSIS, mas também pode se aproveitar de bibliotecas prontas para
os componentes tela(ltdc), memória(dma), serial-paralela(spi), i2c, rcc , usart. O uso
de bibliotecas feita por usuários em outros projetos, também tem se tornado cada
vez mais comum.
Repositórios de código na Internet contêm um grande número de
bibliotecas de software reutilizáveis com uma variedade de funcionalidades. A
reutilização de código de terceiros desempenha um papel central no
desenvolvimento de software moderno e reutilização de bibliotecas de software é a
forma predominante de reutilização (HEINEMANN, Lars)
Assim a criação de um código bem organizado e de fácil
aproveitamento de rotinas, acaba gerando maior agilidade no desenvolvimento e a
qualidade geral do software resultante é melhorada.
Por isso um software que permita uma interação direta entre usuário
e sistema embarcado de forma facilitada como um teclado USB, e que pode ser
adicionado a outros projetos de forma gratuita. Para quem está projetando em
microcontrolador servirá como incremento para projetos e pesquisas futuros.
21
1.4 DESCRIÇÃO DOS CAPÍTULOS
O conteúdo deste trabalho inicia na revisão bibliográfica, onde foi
abordado um pouco da história que conta o início de um interface humana teclado,
da linguagem de programação C e da bem sucedida porta de comunicação USB.
Esse capítulo de revisão bibliográfica aborda também conteúdos úteis ao
entendimento do trabalho como ASCII, conectores, protocolos e classes USB, e do
modo de funcionamento USB On-The-Go.
O capítulo seguinte a revisão mostra superficialmente a descrição do
trabalho em partes e o que cada uma delas tem como função desempenhar. Na
sequências do capítulo tem a descrição do hardware, contendo informações do
fabricante e especificações do produto, o motivo de escolha desses componentes e
como será feita a alimentação de energia do microcontrolador.
O capitulo da descrição do firmware, tem inicialmente os softwares
necessários para utilização do microcontrolador e para a programação do código em
C, como também explicações para as escolha de utilizar esses programas. Nesse
capítulo é mostrados fontes das bibliotecas utilizadas, e também uma descrição das
bibliotecas necessárias para o funcionamento do microcontrolador e da comunicação
USB. As principais funções utilizadas também possuem um breve explicação neste
trabalho. Por fim do capítulo sobre o firmware, foi descrito todo a implementação
realizada especificamente para esse projeto.
22
23
2 Revisão Bibliográfica
2.1 DISPOSITIVO DE INTERFACE
Nesta secção será exposta alguns dos produtos históricos que se
utilizam de funções que precederam a tratadas neste projeto e como também
produtos novos com recursos avançados a fim de facilitarem a interação entre
dispositivos diversos e pessoas.
2.1.1 Cartões Perfurados
Usados pela primeira vez em volta de 1725, e melhorado em 1801
os cartões perfurados foram inventados pelo francês Jacquard para que a máquina
de tear formasse desenhos nos tecidos que estavam sendo fiados sem ter que ficar
trocando os fios e as linhas manualmente a cada passagem. Já na década de 40,
época em que surgiram computadores eletrônico, os papeis ou cartões perfurados,
herdados das maquinas mecânicas, apesar de conterem poucas informações, eram
a melhores forma de incluir dados e comandos nas máquinas.
Como cada cartão, figura 2.1, possui apenas uma declaração, para
executar um programa para a máquina era necessário uma pilha de cartões na
entrada do computador, que levaria horas para processar (KOPPLIN, Jonh).
Figura 2.1: Cartão perfurado com linguagem de programação Fortran.
24
Fonte: http://en.wikipedia.org/wiki/Punched_card
2.1.2 Surgimento do Teclado
Os teclados para computadores foi uma junção natural entres as
maquinas de escrever, que existiam muito antes dos computadores eletrônicos, com
maquinas de perfurar os cartões, da figura 2.2, assim podiam teclar letras
diretamente em cartões perfurados ou fitas magnéticas no caso do BINAC (máquina
seguinte ao ENIAC) em 1948.
Figura 2.2: Máquina de perfurar Cartão.
Fonte: http://www.computersciencelab.com/ComputerHistory/HistoryPt4.htm
Já nos anos 60 surgiram junto com teclados completamente
eletrônicos as telas monocromáticas para exibição em computadores, foram os
primeiros a não utilizar nenhum papel. Essa evolução foi fundamental para
popularização nos anos seguintes dos computadores pessoais. No começo a
velocidade de impressão no ecrã era relativamente lenta em relação a capacidade
humana de digitar.
25
2.1.3 Driver de Dispositivo
Com o aumento da diversidades dos periféricos e da complexidade
de comunicação entre o computador e o periférico, se tornou necessário utilizar
controlador de dispositivo(driver) para realizar a tradução do código genérico gerado
no sistema operacional para baixo nível aplicado ao hardware conectado. Os
sistemas operacionais mais robustos tornaram muito fácil a utilização de qualquer
periférico atual pois sempre que há necessidade de controlar um novo produto, o
sistema é capaz de realizar automaticamente a procura em banco de dados local ou
então online.
Figura 2.3: Instalação automática de driver.
Fonte: http://windows.microsoft.com/
2.2 LINGUAGENS DE PROGRAMAÇÃO
Linguagem de Programação é qualquer método padronizado, que
inclua regras sintáticas e semânticas para comunicar instruções para um
computador (MARCHI, Jerusa). A linguagem de máquina, binário, exigem um longo
tempo e dificuldade para programadores, então surgiu a linguagem assembly,
considerada uma linguagem de baixo nível por ser muito próximo à linguagem de
máquina, era uma notação legível por humanos que era traduzido para linguagem
de máquina por um programa assembler, com uso de tabelas de tradução. O
assembly permitiu aumentar o número de programadores e o desenvolvimento de
aplicações para computadores(Barros, 2003).
2.2.1 Programação EM C
A linguagem C foi desenvolvida na década de 1970 pelo laboratório
da AT&T, por Brian Kernighan e Dennis M. Ritchie, seu uso foi restrito até 1978 e em
26
1983 o instituto norte-americano de padrões (ANSI) formou um comité, para
estabelecer uma especificação do padrão da linguagem C, o padrão foi completo em
1989 chamada ANSI C e após sofrer umas modificações menores, foi adotado pela
Organização Internacional para Padronização (ISO).
A linguagem C tem formato simples e prática sendo considerada um
linguagem de alto nível, utilizada em muitas plataformas por poder ter seu código
portada com apenas pequenas modificações.
Um compilador é o programa que gera código em assembly a partir
da fonte programada em C. Ele pode possui interface para facilitar a implementação
do sistema como também avisa possíveis erros, fornece dicas e atalhos para
funções.
2.3 ASCII
ASCII ou American Standard Code for Information Interchange é o
conjunto de códigos numéricos utilizados para representar texto em computadores e
outros dispositivos, desenvolvida em 1960. Com 128 itens a conhecida como tabela
ASCII necessitava de apenas 7 bits para seus códigos, sendo 33 sinais de controle e
95 sinais gráficos. Os 33 sinais de controle eram úteis na época em que se usavam
maquinas de escrever eletromecânicas, já os 95 sinais gráficos tem como objetivo
representam a língua inglesa apenas.
A Tabela ASCII estendida, com 8 bit, tornou-se necessária para
idiomas latino, essa tabela possui outros 128 sinais gráficos, adicionando caracteres
como cê-cedilha e acento agudo.
Outra forma de codificação que tem superado o ASCII é o Unicode,
com a proposta de representar e manipular, de forma consistente, texto de qualquer
sistema de escrita existente, o Unicode já contém mais de 107 mil caracteres e
símbolos. O padrão também especifica metodologia para codificação, além de
regras para normalização, decomposição, ordenação alfabética e renderização.
Seus 256 primeiros caracteres sendo idênticos aos ASCII para máxima
compatibilidade.
O UTF-8 é um dos tipos de codificação Unicode com a quantidade
de bits variável, assim sendo ela capaz de representar os caracteres ASCII com
apenas 1 byte mas também todos os outros símbolos utilizando de 2 até 4 bytes.
27
Atualmente o UTF-8 corresponde a 85.1% das páginas da internet.
2.4 USB
O USB (Universal Serial Bus), figura 2.4, é o tipo de conexão de
maior sucesso na história, foi desenvolvida por um conjunto de empresas como Intel,
HP, Microsoft, NEC, Philips, Compaq para padronizar as conexões de periféricos ao
computador e ainda permite alternar entre periféricos sem ter que reiniciar o sistema.
O USB traz ao usuário vantagens, por estar sempre pronto para o uso, baixo custo e
boa velocidade de transferência.
Figura 2.4: Conector USB e seu símbolo.
Fonte: http://canaltech.com.br/ e http://en.wikipedia.org/wiki/USB
2.4.1 Conectores
Dois dispositivos conectados por uma interface USB assumem
sempre papeis distintos, um é unidade controladora (host) e outra é unidade
controlada (device). O computador pessoal possui várias portas USB tipo Host,
aonde são conectados os acessórios que possuem portas USB tipo Device (como
câmera digital, mouse, pendrives, impressora).
Para evitar danos elétricos a equipamentos e simplificar a conexão
essas portas tem diferentes formatos, figura 2.5, as chamadas tipo A são do host e
são as que fornecem energia ao barramento, já outra, do periférico é chamada tipo
B. As duas portas podem varia conforme a necessidade de redução do tamanho,
28
gerando os conectores mini-A e mini-B.
Figura 2.5: Modelos de conectores USB.
Fonte: http://eletronicadiaria.blogspot.com.br/p/tipos-de-conectores-usb.html
2.4.2 On-The-Go
A comunicação USB como foi explicada no tópico dos conectores,
possui um diferenciação muito grande entre o dispositivo que controla a
comunicação(host) e o dispositivo que é controlado(slave), porém dispositivos
portáteis aumentaram sua capacidade de processamento e armazenamento
drasticamente, então surgiu um interesse de empresas e consumidores por um
protocolo que permitisse esses dispositivos compartilharem dados entre si e ainda
utilizasse os cabos e acessórios padrões. (Remple, 2003).
As especificações para o USB On-The-Go (OTG) foram liberadas
em 2001, e definem uma capacidade limitada da função de host para que
dispositivos pudessem comunicar com outros periféricos. Por exemplo, um usuário
29
pode querer conectar uma câmera diretamente a uma impressora ou ligar duas
unidades em conjunto para trocar arquivos (Axelson, 2005).
Figura 2.6: Exemplos de conexões para dispositivos OTG.
Fonte: Philips (2002)
Quando funcionando como host, o dispositivo OTG pode se
comunicar com outros dispositivos que estejam em sua lista de periféricos
direcionados, a lista pode ser tão limitado a um único dispositivo, bem como uma
extensa variedade de dispositivos (teclado, mouse, armazenamento em massa). A
lista pode ser qualquer combinação entre outros dispositivos OTG e periférico do
modo dispositivos apenas (Axelson, 2005).
Uma das maiores limitações que dispositivos OTG tem em relação a
dispositivos apenas host (PC), é por serem geralmente de baixo consumo e
energizados por bateria, assim as especificações permitem que seja feita uma
controlador OTG com uma baixa potência disponível na porta USB, impossibilitando
de se usar discos rígidos USB e também, em geral, não há compatibilidade com
HUB USB.
Dispositivos com essa capacidade só tornaram comum com os
celulares que possuem o conector micro-AB. O funcionamento depende do
dispositivo OTG reconhecer, através do aterramento do pino 4 no próprio cabo,
figura 2.7 e 2.8, se está conectado a um host principal(Computador) ou a um
30
periférico.
Figura 2.7: Detalhe conector USB micro-A e micro-B.
Fonte: Próprio autor.
Figura 2.8: Diagrama da conexão entre dispositivos
Fonte: ZHIGUI, DEJUN, QINGQING (2011)
O uso de diferentes cabos para cada função é necessária para
definir qual dispositivo irá energizar o barramento, um cabo USB com pontas tipo A e
outra micro-B, faz com que o celular responda como um periférico, já para função
host utiliza-se o cabo USB com as pontas micro-A e um conector tipo-A femêa,
conhecido como cabo OTG, figura 2.9.
31
Figura 2.9: Cabo USB OTG.
Fonte: Próprio autor.
2.4.3 Taxa de Transmissão
O USB possui três diferentes taxas de transmissão, sendo elas High-
Speed, Full-Speed ,Low-Speed. O High-Speed tem taxa de 480 Mbps e é utilizado
quando há transferência de imagens e armazenamento de dados em HDs externos,
o Full-Speed 12Mbps é utilizado para bandas médias como transferência de áudio, e
o Low-Speed 1,5 Mbps é utilizado para mouse e teclado. O Low-Speed possui um
custo muito baixo, o de Full-Speed tem um custo baixo e a largura da banda
razoável.
2.4.4 Cabo USB
O sistema de USB 1.0 e 2.0 utilizam quatro fios: +Vcc, +D, -D e
Terra, tabela 2.1, e uma malha para eliminar ruídos. Os fios Vcc e terra fornecem
energia, do host para o dispositivo, a tensão nominal é 5[V], os fios +D e -D, por
onde ocorre toda a comunicação, são entrelaçados para cancelar
as interferências eletromagnéticas.
O comprimento do cabo é limitado em cinco metros, para permitir
que a tensão de linha, devido a reflexões, estejam resolvidas antes do próximo bit
ser enviado, caso contrário, reflexões podem interferir e causa indeterminação.
32
Tabela 2.1: Padrão dos fios de um cabo USB.
Pino sinal Color Descrição
1 VCC
+5V
2 D-
Informação -
3 D+
Informação +
4 GND
Terra
Fonte: http://pinouts.ws/usb-pinout.html
Para o OTG um quinto pino chamado ID-pin foi adicionado na quarta
posição do conector tipo micro-AB, se o novo pino estiver a aterrado a porta será
equivalente a uma micro-A, enquanto se estiver flutuando o conector será do tipo
micro-B.
2.4.5 Protocolo de Comunicação
O protocolo USB é baseado em pacotes de dados, ao ocorrer a
inserção do periférico, e o USB Host tomar conhecimento da conexão devido um
resistor pull-up no dispositivo e inicia o processo de enumeração e comanda todas
as transações subsequentes nele. Os periféricos do barramento podem ser
funcionais (teclado, mouse, armazenamento, etc.) ou hubs, utilizados para conectar
outros dispositivos em cascata ou em estrela. (Zuquim, Ana. L. A. P.)
Os dispositivos contêm um número de registradores individuais,
conhecidos como endpoints, eles são os únicos campos endereçável de um
dispositivo USB, são neles que as informações são gravadas ou lidas pelo host,
durante a comunicação USB. Cada transação inicia com um pacote que determina o
tipo de transação que será executada e o endereço do endpoint. Esse
endereçamento é controlado pelo software USB. Quando a transação é enviada pelo
barramento, todos os dispositivos (exceto os de baixa velocidade que tem sua porta
desabilitada neste momento) identificarão sua presença.
Todas as transações do barramento envolvem a transmissão de até
três pacotes, figura 2.10. As transações sempre se iniciam no USB host, quando
este necessita comunicar com seu dispositivo, envia um pacote (Token Packet),
33
tabela 2.2, descrevendo o tipo, o sentido de transmissão, o endereço do dispositivo
USB e o referido número de endpoint, em seguida o pacote de dados (Data Packet),
tabela 2.3, é enviado, que pode ser tanto do dispositivo para o host como do host
para o dispositivo, e por fim o destinatário responde com a confirmação de
recebimento dos dados (Handshake Packet), tabela 2.4.
Figura 2.10: Transferências de pacotes.
Tabela 2.2: Token Packet.
Pid Endereço Endpoint CRC
Nº bits 8 7 4 5
Fonte: http://www.gta.ufrj.br/
Packet Identifier(Pid):Possui oito bits, os quatro primeiros descrevem a
intenção do host em ler(1001), gravar(0001), configurar o dispositivo(1101),
ou sincronizar(0101). Os quatro últimos bits verificam a integridade dos
dados.
34
Endereço: Identifica para qual dos dispositivos foi enviado, com sete bits,
limita a um total de 127 dispositivos USB conectados a porta, quando se
utiliza HUBs.
Endpoint: Representam o número do endpoint do dispositivo envolvido.
Cyclic Redundancy Checks(CRC):Verificados da integridade dos dados de
endereço e endpoint.
Tabela 2.3: Pacote de dados.
Pid Informação CRC
Nº bits 8 0 - 8192 16
Fonte: http://www.gta.ufrj.br/
O pacote de dados possui um identificador, a informação e o
verificador. Dispositivos de baixa velocidade como o teclado limitam-se ao máximo
de 8 byte por pacote de dados.
Após o pacote contendo a informação ser recebido, o receptor envia
a confirmação da recepção com Handshake packets.
Tabela 2.4: Pacote de confirmação.
Pid
Nº bits 8
Fonte: http://www.gta.ufrj.br/
O protocolo USB permite quatro tipos diferentes de formas de
transmissão: Controle, Bulk, Interrupção e isócrono.
Controle: Utilizada pelo host para fazer requisições ao dispositivo dos seus
descritores de dispositivo e de configurar um dispositivo quando eles são
conectados pela primeira vez.
Bulk: É utilizado para transmissão de grande quantidade de dados de uma
vez, como em impressoras e scanners. É livre de erros, pois ocorre
verificação e a retransmissão se necessário. Esse tipo de transmissão tem
baixa prioridade.
35
Interrupção: Para transferência de pequena quantidade de dados. Apesar de
chamar interrupção, o host ‘sonda’ os dispositivos e caso seja necessário, a
transferência é feita. O intervalo de verificação é denominado Polling Interval.
Comum em Teclados e mouses.
Isócrono: Comunicação que garante a entrega dos dados dentro de um
determinado tempo, útil para transmissões de áudio. Nesse caso não importa
se alguma informação for corrompida, desde que se mantenha a fluxo de
dados, por isso não é ocorre a confirmação da recepção(handshake)
Os dispositivos USB contêm um conjunto de descritores, figura 2.11,
que especificam os atributos e características do dispositivo. Essa informação é
necessária para que o host configure o dispositivo e localize seu respectivo driver.
Cada dispositivo possui um endpoint 0, que é reservado para configuração. É
através desse endpoint que o software de sistema acessa os descritores do
dispositivo. (Zuquim, Ana. L. A. P.)
Figura 2.11: Estrutura dos descritores de dispositivo.
Fonte: http://www.beyondlogic.org
O primeiro descritor que o host requisita é o descritor do dispositivo
padrão (Standard Device Descriptor). As informações presentes nele são: primeiro a
quantidade de bytes desse descritor, a qual versão das especificações USB esse
dispositivo compatível, a qual classe USB ele pertence, subclasse, protocolo de
classe, tamanho máximo do endpoint 0, Identificação da marca, identificação do
36
produto, versão do produto, nome da marca, nome do produto, serial e quantidade
de possíveis configurações (USB Specification, 2000).
No descritor de dispositivo foram definidas quantas configurações
serão possíveis, a maioria dos dispositivos só possui uma. Cada configuração possui
um descritor de configuração, nele está descrito, entre outras informações, quantas
interfaces serão necessárias nesse modo de configuração. Cada interface terá um
descritor de interface, com a quantidade de endpoint dela, e o endpoint também terá
seu próprio descritor, que descreverá qual protocolo de comunicação e velocidade
será usado nele, entre outra informações.
2.4.6 Classes de Dispositivos USB
Quando um grupo de dispositivos ou interfaces compartilham muitos
atributos ou fornecem ou solicitam serviços similares, faz sentido definir os atributos
e serviços em uma especificação de classe. (Axelson, 2005).
Assim o padrão USB definiu as classes para que dispositivos com as
mesmas funções possam ser controlado em um host utilizando um mesmo driver de
dispositivo com base naquela funcionalidade em comum.
As classes de dispositivos mais frequentes são a de
armazenamento, interface humana, impressoras, hub, áudio, imagem, vídeo,
interface física, controle wireless(com várias sub classe: wifi, radio, bluetooth). Cada
classe possui tipos de requisição e descritores específicos.
A informação do código de classe na qual o dispositivo pertence
pode ser obtido no descritor de dispositivo, a informação também está presente no
descritor de interface. (USB Device Class Definition, 2001).
A classe dos dispositivos de interface humana(HID) incluem
teclados, mouses, leitor de códigos de barra, controle de jogos e outro dispositivos
que a entrada de informação seja pela ação de uma pessoa. Nessa comunicação o
host deve ser rápido o suficiente para que o usuário não perceba uma atraso entre a
ação feita e a resposta esperada. Assim apenas transferências do tipo controle e
interrupção são utilizadas, e em geral low speed é rápido o suficiente para interface
humanas e é mais comum devido ao baixo custo, porém qualquer velocidade pode
ser utilizada.
37
2.5 TECLADO
O teclado a principal forma de entrada de dados em um computador,
oferece funções ativadas por teclas. Seu design originado da máquina de escrever,
tem evoluído muito na parte de ergonomia, e padrão de comunicação. A disposição
de teclas mais popular conhecido como QWERTY favorece a escrita em inglês, mas
outras disposições de teclas também existem como QWERTZ(alemão) e
AZERTY(Francês).
O funcionamento do teclado se baseia em matrizes de contato,
figura 2.12, quando uma tecla é pressionada fecha um contato elétrico entre duas
folhas de circuito como vistos na imagem, um processador localizado no teclado
percebe o acontecido, e compara sinal elétrico da matriz do teclado a um tabela de
consulta na sua memória de apenas leitura (ROM). A tabela consta cada possível
contato e a qual tecla ele representa. (LUÍS, Bruno.; PACHECO, Carla. 2002)
Figura 2.12: Matrizes de contato do teclado.
Fonte: http://www.tecmundo.com.br
38
2.5.1 Padrões de Conectores
Na década de 1990 teclados utilizava o conector “DIN”(Deutsche
Industrie Norm). Devido ao seu tamanho, com o tempo, os fabricantes começaram a
utilizavam o conector “mini-DIN” (ou PS/2), que acabaram se tornando o padrão e
até hoje podem ser encontrados. Com a evolução do equipamento e adição de
novos recursos, os novos teclados estão sendo fabricados com conector USB,
devido à grande aceitação do padrão em todo o mundo e a variedade de aplicações.
2.5.2 Formato de envio das informações
A informação recebida do teclado devem sempre ser requisitada
pelo host, o teclado então responde com um relatório, contendo 8 bytes, tabela 2.5,
com a informação de um ou mais itens pressionados, e a interpretação dos itens
individuais é feita pelo software.
O primeiro byte é formado pelas teclas de modificação: ctrl, shift, alt
e iniciar, com diferenciação de direita e esquerda em todas. Cada uma delas é
representada por 1 bit, assim essas teclas podem ser pressionadas em quaisquer
combinação entre si ou juntamente com outros caracteres e o software ainda será
capaz de diferencia-las sem dificuldades.
O segundo byte é reservado, sempre preenchido de zeros.
O terceiro ao oitavo byte são utilizados pelo teclado para enviar as
demais teclas do A, B, C ao F1, setas e etc. Sendo necessário vários bytes apenas
se for pressionado várias teclas ao mesmo tempo. Caso apenas uma tecla for
pressionada, o byte 2 envia seu respectivo código e todos outros na sequência
permanecem zero, se a manter pressionada e pressionar uma outra tecla o byte três
a informa a nova tecla enquanto o byte 2 continua informando a primeira. Assim é
possível pelo protocolo uma combinação de até seis teclas, porém as combinações
com teclas próximas acabam sendo limitadas por ligações físicas do teclado.
39
Tabela 2.5: Estrutura da informação recebida do teclado
Fonte: http://www.microchip.com/.
40
41
3 DESCRIÇÃO DO PROJETO
Nesta seção será feita uma descrição superficial sobre o projeto,
para mais fácil compreensão das funções do mesmo
3.1 DIAGRAMA DESCRITIVO
A estrutura básica do projeto é a imagem 3.1, ela representa o
trajeto das informações para um usuário do sistema.
Figura 3.1: Diagrama descritivo.
Fonte: Próprio autor.
3.2 TECLADO USB
O teclado é utilizado no projeto para se introduzir ou alterar
informações no display, como também pode ser utilizado para comandar funções do
microcontrolador ou de outro hardware conectado a ele.
3.3 CABO ADAPTADOR USB OTG
O cabo adaptador realiza as conexões elétricas diretas entre suas
pontas, do tipo USB micro-A para USB tipo A fêmea, necessário para conectar um
típico teclado USB com a placa do projeto.
Esse adaptador é bastante comum, podendo ser encontrado em
lojas de celular, serve para realizar uma comunicação USB On-The-Go(OTG)
explicada na revisão bibliográfica.
42
3.4 MICROCONTROLADOR ARM
O microcontrolador, onde se conectam todos os componentes, tem
entre suas funções, definidas pelo software, inicializar o teclado e o display, se
comunicar com o teclado USB e reconhecer seus código, e comandar o display.
Mais funções como enviar mensagem ou comandos via RS232 para outras placas
podem ser incluídas.
O modelo do microcontrolador é o stm32f429, o modelo foi escolhido
por possui conexão USB com possibilidade de host OTG e display TFT LCD já
montados na placa, assim facilitando o uso e evitando ter problemas de mal contato,
a placa também possui um processador ARM M4 capaz de realizar todas as funções
do projeto sem atrasos. O processador e outros componentes que foram utilizados
serão descrito na próxima seção.
3.5 SOFTWARE
O software é a principal parte deste projeto, responsável por
comandar o microcontrolador e suas funções, como também conter todas as rotinas,
protocolos e tabela com valores. Todas suas funções e processos serão
demonstrados na seção 5.
3.6 DISPLAY TFT LCD
O display de cristal líquido colorido com 2,4 polegadas e resolução
QVGA(320x240) presente na placa do microcontrolador será a interface de saída
para usuário interagir com o programa, ele é utilizado neste projeto para exibir
informações e caracteres de texto conforme for sendo digitado ou editado. A tela
também é sensível ao toque, apesar de estar funcional não tem grande importância
ao projeto.
43
4 DESCRIÇÃO DO HARDWARE EMBARCADO
Nesta seção será especificado em detalhes o hardware embarcado
e seus componentes, utilizados para o funcionamento do projeto.
4.1 STM32F429
O primeiro microcontrolador a ser cogitado para o projeto foi
stm32f103, que apesar de possuir a conexão USB nativa em sua placa, não é capaz
de realizar uma conexão USB On-The-Go.
Para o um microcontrolador ser o host da conexão USB é
necessário além da programação, ter compatibilidade de clock, comparadores de
tensão na porta USB, uma interface serial, resistores pull-up e pull-down e um
registrador.
O clock de 48 MHz, gerado por cristal e PLL, é necessário para
comunicação USB full-speed e low-speed. Os comparadores determinam a tensão
no pino Vcc (VBUS) para determinar o estado do barramento. A interface serial
transfere dados do e para os buffer do receptor, e utiliza o protocolo de hardware
para a transferência de dados. O barramento USB transfere os dados entre a
memória RAM e interface serial. O resistores integrado pull-up e pull-down eliminam
a necessidade de componentes externos de sinalização. O registrador permite que a
CPU configure e comunique com a porta USB.
Foi então que foi escolhido uma placa stm32f429, que possui a
capacidade de ser host OTG de uma de suas portas USB além de ter maior
capacidade de processamento.
O stm32f429i-discovery é um microcontrolador de alta performance
da STMicroelectronics, lançado em versão inicial em setembro de 2013. Ele inclui
em sua placa: processador Cortex M4, 2 MB de memória Flash, 256 KB de
RAM, programador ST-LINK/V2 para programação e depuração, uma tela 2,4
polegadas QVGA TFT LCD, 64Mbits SDRAM, giroscópio, seis LED, dois botões e
uma porta USB OTG micro-AB.
44
Figura 4.1: STM32F429 componentes frente.
Fonte: Próprio autor.
45
Figura 4.2: STM32F429 componentes atrás.
Fonte: Próprio autor.
4.1.1 Processador Cortex-M4
O núcleo de processamento do stm32f429 é um Cortex-M4 da
empresa ARM, é um processador de sinais digitais embarcado de alta performance,
que pode funcionar com frequência interna de até 180MHz, configurado nesse
projeto para 168MHz, com 32 bit e ponto flutuante. Com ampla possibilidade de
46
aplicações para consumidores como também para uso Industrial, sistemas de
segurança e médica.
4.1.2 Interfaces USB Presente no stm32f429
O microcontrolador STM32F429 possui duas interfaces USB, em
uma delas está o circuito do programador para conexão com um computador, sendo
necessário para programação apenas o cabo USB comum do tipo A para mini-B
USB e dispensando o uso do cabo ST LINK/V2, a outra porta é uma micro-AB USB
do tipo OTG, ou seja, pode assumir tanto o papel de uma porta USB de dispositivo,
como o de uma porta USB Host.
4.1.3 Alimentação do Stm32f429
A energia para funcionamento completo da placa é fornecida pelo
computador por meio do cabo mini-B USB em 5V, mas também pode ser fornecida
por uma fonte externa diretamente conectada no barramento de 5V.
Para não ser necessário o uso do computador foi utilizado um
carregador de celular Motorola no mesmo padrão mini-B USB, e pode-se ainda
utilizar bateria portátil desde que a mesma tenha a conexão USB.
4.2 TECLADO USB
É esperado que o projeto funcione com qualquer teclado qwerty na
disposição ABNT2, sendo compatível com todos os caracteres, acentos e
pontuação.
O teclado utilizado na maior parte do trabalho foi um modelo abnt2
da marca CLONE código 09198 homologado pela ANATEL. Este produto apresenta
conexão padrão USB porém sem fio, e funcionou sem maiores problemas.
47
Figura 4.3: Teclado USB utilizado
Fonte: Próprio autor.
48
49
5 DESCRIÇÃO DO FIRMWARE
5.1 INTERFACE DE DESENVOLVIMENTO
A empresa STMicroelectronics, fabricante do microcontrolador,
disponibiliza diversas bibliotecas e exemplos a alguns ambientes de
desenvolvimentos, entre eles IAR, keil, TrueSTUDIO. Porém esses IDE, são
software’s pagos e que possuem apenas versões de testes sem custos apenas para
estudantes ou por tempo limitado. Como o projeto deve ser de fácil aproveitado
como parte de outros projetos fututos, o ambiente de desenvolvimento escolhido foi
o CoIDE da Coocox.
5.1.1 COIDE
Interface de desenvolvimento da Coocox foi projetada e lançada em
2009 pela empresa Embest juntamente com a Wuhan University of Technology na
china, o crescimento levou a se tornar uma marca global e independente, Coocox.
Atualmente a ferramenta CoIDE, figura 5.1, é disponibilizada gratuitamente inclusive
para uso comercial e sem limitações e possui um grande número de bibliotecas e
exemplos práticos que são feitas pela própria Coocox, ou então compartilhadas
pelos milhares de usuários registrados que utilizam a ferramenta.
O foco dessa IDE é a programação em microcontroladores ARM
Cortex M0/M0+/M3/M4. E ela usa GCC-ARM-Embedded tool chain para compilação.
50
Figura 5.1: CoIDE.
Fonte: Próprio autor.
5.2 BIBLIOTECAS
As bibliotecas são os arquivos que fornecem funções prontas, de
uso comum, para serem utilizados em outros programa. As primeiras bibliotecas
adicionadas ao projeto serviram para a inicialização da placa stm32f429. Para os
processadores cortex, existe o conjunto de bibliotecas CMSIS (Cortex Microcontroler
Software Interface Standard), além delas também foram utilizadas bibliotecas para o
display sensível ao toque, outro componentes da placa e as várias bibliotecas da
comunicação USB.
5.2.1 CMSIS
Criado pela ARM em 2008, o CMSIS é uma camada de abstração de
hardware independente de fabricante para a série processador Cortex-M. Para
padronizar as interfaces de software e simplifica a reutilização de códigos em todos
os produtos Cortex-M, com isso significativas reduções de custos especialmente ao
criar novos projetos ou a migração de software existente para um novo
dispositivo.(ARM 2008).
51
Figura 5.2: Estrutura CMSIS.
Fonte: http://www.arm.com/.
O CMSIS é o pacote de bibliotecas base para funcionamento do
microcontrolador deste projeto, figura 5.2, ele contém os seguintes arquivos:
Core_cm4.h: Define os periféricos essenciais ao núcleo e fornece funções
que acessam os registradores do processador Cortex-M4.
Core_cmInstr.h: Define as funções intrínsecas para acessar instruções
especiais Cortex-M.
Core_cmFunc.h: Define as funções para acessar os periféricos Cortex-M.
Core_cm4_simd.h: Define as funções intrínsecas para acessar as instruções
SIMD (Single Instruction, Multiple Data) para Cortex-M4 e Cortex-M7.
Stm32f4xx.h:Contém a quantidade de exceções e interrupções do dispositivo
e definições para o acesso de periféricos.
System_stm32f4xx.c: Adaptado do arquivo de modelo system_ <device>.c
fornecido pela ARM para que sirva ao dispositivo stm32f4. No mínimo, este
arquivo deve fornecer, configuração específicas do dispositivo, configuração
de clock, PLL e fatores de divisão.
System_stm32f4xx.h: Em caso de recursos adicionais os protótipos de função
precisam ser adicionados nesse arquivo.
startup_stm32f4xx.c: O que controla o reset e tipicamente o local da função
SystemInit().
52
Também foi utilizado outras bibliotecas referentes a periféricos da
placa: stm32f4xx_dma2d.c, stm32f4xx_fmc.c, stm32f4xx_gpio.c, stm32f4xx_i2c.c,
stm32f4xx_ltdc.c, stm32f4xx_rcc.c, stm32f4xx_spi.c, misc.c
5.2.2 STM32Cube
Uma forma de se obter as bibliotecas e código base para projetos, é
da própria STMicroelectronics com a utilização do programa STM32Cube para
Windows, bastando selecionar o tipo de processador ou placa utilizada, é possível
gerar o código C de inicialização seguindo o processo passo a passo com interface
gráfica e intuitiva.
Ele permite visualizar e alterar diretamente entre recursos que
podem ser adicionados no arquivo do projeto, como também escolher a função que
cada pino de entrada e saída do chip exercerá, figura 5.4, assim evitando conflito
entre funções que estão no mesmo pino. Nele também há visualização das
frequências utilizadas em diversas partes da placa, figura 5.3, e cálculo da potência
de consumo esperada.
Por fim esse software gera os arquivos de projetos prontos para
serem utilizados na interface de desenvolvimento e compilados (STMicroelectronics).
Porém ele não é diretamente compatível com a interface Coocox utilizada, ainda
assim as bibliotecas podem ser adicionadas manualmente no arquivo projeto.
53
Figura 5.3: Interface para controle de frequência STM32Cube.
Fonte: Próprio autor.
Figura 5.3: Interface para controle dos pinos STM32Cube.
Fonte: Próprio autor.
54
Os pinos utilizados para comunicação USB: PB12, PB13, PB14,
PB15 podem ser vistos no canto inferior direito da figura 5.4, esses são fisicamente
conectados na porta USB micro-AB.
5.2.3 Tela Sensível ao Toque
O display utilizado no projeto é um componente fixo a própria placa,
devido a isso, existem bibliotecas, e funções desenvolvidas para ele. Exemplos de
sua utilização também são facilmente encontrado. As bibliotecas do display e touch
utilizadas no projeto são desenvolvidas por, Uwe Becker, e disponibilizadas em seu
site mikrocontroller.bplaced.net para uso sem limitações.
O display possui internamente o controlador ILI9341, a comunicação
entre stm32f429 e o controlador do display é realizada pela interface SPI(serial-
paralela), e parte da memória SD-RAM da placa também é utilizada para comandos
do display. Por isso as bibliotecas SPI e SDRAM também estão incluídas.
Essa bibliotecas realizam a inicialização do display e da
sensibilidade da tela, alinhamento, controle de cores e trazem funções, como
desenhar formas geométricas, imprimir caracteres, uso de camadas e transparência.
As cores são representada no padrão highcolor com 16 bit de
definição, 5 bit para o dar tom de azul, 5 bit para o vermelho e 6 bit para cores
verdes, esse método de representar cores da maior relevância as cores verdes
devido a visão humana ter maior capacidade de diferenciar cores nesse tom.
5.2.4 Impressão de Caracteres
Após a tecla pressionada ser reconhecida e interpretada como
caractere do código ASCII, o comando de imprimir busca o respectivo código em
uma tabela de valores que representam os formatos do mesmo em pixels.
A tabela foi gerada com o software pixelfontgenerator, que utiliza
fontes do Windows como molde para obter os valores, porém alguns caracteres
tiveram que ser ajustados manualmente para melhor visualização.
A tabela representar aproximadamente a fonte Arial, inicialmente
com tamanho máximo de 11 pixel de largura e 18 de altura, porém para o uso de
acentuação do teclado ABNT, se mostrou necessário reduzir a altura de alguns
55
caracteres e ainda adicionar mais duas linha, ficando com 11x20 pixels.
Figura 5.5: Representação de caractere em pixel na tela.
Fonte: Próprio autor.
O caractere possui 20 linhas, cada linha é um número de 4 dígitos
em hexadecimal,16 bit, apenas os 11 bits mais significativos são utilizados para o
formar os pixel da linha, o caractere "A" maiúsculo, código ASCII 65, possui os
seguintes valores na tabela de impressão 0x0000,0x0000,0x0E00,0x0E00,
0x1B00,0x1B00,0x1B00,0x1B00,0x3180,0x3180,0x3F80,0x3F80,0x3180,0x60C0,0x
60C0,0x60C0,0x0000,0x0000,0x0000,0x0000, já o "Á" maiúsculo e com acentuação
código ASCII 193, possui os valores 0x0300,0x0600,0x0c00,0x0000,
0x0E00,0x0E00,0x1B00,0x1B00,0x3180,0x3180,0x3F80,0x3F80,0x3180,0x60C0,0x
60C0,0x60C0,0x0000,0x0000,0x0000,0x0000. As representações desse valores
estão na Figura 5.5.
A função imprimir, recebe o tamanho do caractere, e a posição
do mesmo na tabela de caracteres(respectivo valor ASCII), a varredura ocorre
primeiro na linha, lendo o número hexadecimal e comparando com um máscara
0x800(1000 0000 0000) em conjunção (and), caso o bit de maior significância no
valor da linha também for 1, o resultado 1 da conjunção permite imprimir um pixel na
respectiva posição da tela, em seguida a máscara é deslocada com um comando
"mascara >>1" ou poderia ser realizado com uma divisão por 2, e assim a segunda
iteração compara "1" com a segundo bit de maior significância da linha, até o último
bit e depois com outras linhas.
56
5.2.5 USB
As bibliotecas para comunicação USB On-The-Go host e device são
fornecidas pela própria fabricante STMicroelectronics, junto com o manual UM1021
para utiliza-las.
Existem bibliotecas para diversas funções USB, figura 5.6 e figura
5.7, elas não são todas necessárias a um mesmo projetos, depende de quais
classes USB serão compatíveis e se o programa realizará função de host, de um
dispositivo ou as duas.
Figura 5.6: Organização dos conjuntos de bibliotecas USB.
Fonte: Manual UM1021 da STMicroelectronics.
Para que a placa stm32 faça função de um host USB quando se
comunica com algum dispositivo, deve-se utilizar além das bibliotecas de baixo nível
USB, protocolos de interrupção e driver de acesso ao núcleo. Também são
necessárias as bibliotecas da classe ou das classes. As bibliotecas de classes
contém os protocolos específicos para implementação de dispositivo USB: HID,
MSC, DFU, áudio, CDC.
Para esse projeto foi utilizada as bibliotecas para com as quais a
placa stm32 comandará outro dispositivo USB da classe HID (human interface
device), para isso utilizou-se as seguintes biblioteca:
57
usb_core.c/h: Este arquivo contém a camada de abstração de hardware e as
operações de comunicação USB.
usb_conf.h: Este arquivo contém a configuração que seleciona modo Host,
dispositivo ou modo OTG, tamanho FIFO(First In, First Out) transmitido,
tamanho FIFO a receber, no modo host. e recursos selecionados ... etc.
usb_bsp.c/h: Este arquivo contém configuração sobre interrupções, métodos
de atraso e GPIO. Este arquivo deve ser modificado em função das
necessidades de aplicação.
Estes arquivos acima são a camada de interface do núcleo, e são
necessários para toda forma de utilização USB da placa, host ou dispositivo,
incluindo todas as classes, porém algumas configurações devem ser alteradas, por
exemplo as escolha das portas de entrada e saída. Na utilização atual o arquivo bsp
está definido para utilizar os pinos PB12, PB13, PB14, PB15 os quais são
conectadas fisicamente ao conector USB micro-AB da placa stm32f429.
usb_hcd.c/h: Este arquivo contém a camada de interface host usado pela
biblioteca para acessar o núcleo.
usb_hcd_int.c/h: Este arquivo contém as sub-rotinas de interrupção para o
host controlar os eventos USB
Os arquivos hcd(host core driver) são comandos de baixo nível
apenas necessários para funções de host.
58
Figura 5.7: Organização dos conjuntos de bibliotecas USB host
Fonte: Manual UM1021 da STMicroelectronics.
usbh_core.c/h: Esse arquivo contém as funções para o núcleo comandar o
processo de enumeração USB e o estado da comunicação.
usbh_stdreq.c/h: Este arquivo contém as funções de requisição para realizar a
enumerção do dispostivo conforme capitulo 9.4 da especificação USB.
usbh_ioreq.c/h: Este arquivo controla os envios e recebimentos da
comunicação.
usbh_hcs.c/h: Este arquivo possui as funções de alocar ou liberar canais para
os endpoint do dispositivo.
usbh_conf.h: Onde configurado o número máximo de interfaces, o número
máximo de endpoint e o tamanho máximo dos pacotes de dados.
usbh_usr.c/h: Possui funções callbacks do processo USB, servem para
informar estado da comunicação
Por fim existem as bibliotecas especificas para classes USB, foi
utilizado a classe HID para se comunicar com o teclado USB, essa biblioteca
59
também permite comunicação com mouse, superfícies sensíveis ao toque USB,
leitor de código de barras, joystick e controles de vídeo game USB.
usbh_hid_core.c /h: Este arquivo implementa inicialização e controle da
classe.
usbh_hid_keybd.c /h: Rotinas especificas para o teclado, decodifica a
informação recebida do teclado, converter em seu respectivo caractere ASCII.
5.3 PRINCIPAIS FUNÇÕES
As funções de maior importância e complexidade serão explicada
para mais fácil interpretação caso necessitem modificações em futuros projetos. Nos
arquivos do projeto as linhas de código estão comentadas pelo mesmo motivo.
USB_Init(void): É executada apenas uma vez na inicialização, criada para
modifica o estado da comunicação USB para desconectado, redefini algumas
variáveis globais, chama a função USBH_Init(&USB_OTG_Core_dev,
USB_OTG_HS_CORE_ID, &USB_Host, &HID_cb, &USR_Callbacks), assim
indicando diversas e extensas estruturas de variáveis que serão utilizadas
para alocar informação durante a comunicação e também indicando que será
utilizado as bibliotecas de classe HID.
USBH_Init(): Original das bibliotecas feitas da STMicroelectronics, essa
função faz a configuração de pinos e clock, registro de classes e ativação de
interrupções necessárias para a função host USB.
As funções que serão explicadas a seguir são chamadas
periodicamente no laço while(1) da main, e necessitam diversas passagem para
funcionar. O programa sempre verifica o estado da comunicação USB armazenado
na variável "host_status" para decidir o que fazer durante a interação.
USB_function(void): Principalmente chama função
USBH_Process(&USB_OTG_Core_dev, &USB_Host), mas se detectar
problemas de reconhecimento ou não obtiver resposta em longo período, não
a chama mais. Também retorna o estado atual da conexão entre as possíveis:
60
Não inicializado, Nenhum dispositivo conectado, Velocidade suportada,
Velocidade Erro, Dispositivo não suportado, Sobrecorrente, USB Conectado,
Teclado pronto.
USBH_Process(): Essa é a função feita pela STMcroelectronics é a mais
complexa do projeto, ela reconhece o estado da comunicação USB e para
cada caso, como na imagem 5.8, realiza diferentes funções, por exemplo
durante a enumeração que ocorre em também em diversos estágios internos
de leitura de descritores de dispositivos, endereçamento, e escolha da
configuração do dispositivo. Essa função também é a responsável, realizar o
controle de classe, no caso do projeto, fazer requisições periódicas para o
teclado por novas informações.
Figura 5.8: Diagrama da função USBH_process.
Fonte: Manual UM1021 da STMicroelectronics.
key_function(void): Essa rotina controla a posição do texto, onde inicia e os
espaçamentos, como também controla a maior parte da interpretação do que
foi teclado. Primeiro chamam as funções responsáveis por coletar o valor
ASCII (get_key()) e borda de subida (get_key2()), obtidos durante o
61
USBH_Process() e as armazena numa variável local para utilização, na
grande maioria das vezes irá retornar vazio, pois tanto o valor ASCII como a
flag de borda de subida só é recebido uma única vez quando ocorre variação
no valor do buffer do teclado, independentemente do tempo com que a tecla
fique pressionada. Em seguida, utilizando esses valores, ocorre um controle
de repetição da tecla pelo tempo pressionada, de forma similar a um
computador. A função para decidir pela acentuação de teclas é chamada, e
então o programa chamar a função imprimir o caractere ou realizar sua
respectiva função(Enter, Caps Lock, BackSpace,etc) e por fim move e
desenha o cursor conforme o que foi decidido
GetKey(): Simples função que retorna o valor ASCII se for diferente de zero e
zera a variável onde ele estava salvo.
KEYBRD_Decode(uint8_t *pbuf): Realiza a decodificação da informação
recebida do teclado, separando em 6 teclas, converte a última em ASCII,
baseado em tabela. Também identifica e exporta comandos como
BackSpace, CapsLock, Enter ,Tab e setas direcionais e informa borda de
subida.
verificaracentos(ascii_code):Nessa função, se argumento ASCII de entrada
for um acento, ela o armazena e o valor ASCII retorna da função vazio. Em
outro caso se o valor ASCII for referente a uma vogal e a função já tiver um
acento armazenado, ela retornará um valor ASCII referente a combinação da
vogal e do acento. Em quaisquer outro caso ela retornará o mesmo valor do
argumento sem alteração.
UB_Font_DrawChar(x,y,ascii_code,&Arial_11x20,aktColor,RGB_COL_WHITE
): Para imprimir um caractere ASCII pixel por pixel na tela, os argumentos
representam respectivamente: posição horizontam e vertical, valor ASCII,
tabela de valores para o grafismo do caractere, cor e cor do segundo plano. O
seu funcionamento está explicado no capitulo 5.2.4
62
5.4 PROCEDIMENTO
Nesta secção serão explicados os procedimento tomados para
fazer com que a placa stm32f429, funcione e utilize dos recursos USB OTG.
5.4.1 Pré-requisitos
Ter instalado no Windows a interface de desenvolvimento CoIDE
juntamente com o compilador GCC Toolchain. O driver do gravador ST-LINK/V2 é
necessário mas foi instalado automaticamente pelo Windows ao ser detectado.
Em hardware é necessário um microcontrolador ARM com suporte
USB OTG, como os da STMicroelectronics STM32F105, STM32F107, STM32F2xx e
STM32F4xx. Os cabo USB para programação e USB OTG e um teclado USB.
5.4.2 Início do Projeto
Como o software STM32Cube da STMicroelectronics não gera
projetos para a interface CoIDE da Coocox e a própria CoIDE até a data desse
projeto não possui em seus banco de dados as bibliotecas de inicialização para
stm32f429, seria necessário a criação de projeto em branco e então adicionar as
bibliotecas CMSIS implementadas para a stm32f429. Foi preferível iniciar o projeto a
partir de um exemplo feito para CoIDE, o exemplo já adicionava diversas funções da
tela e touch úteis para o impressão dos caracteres.
A partir deste exemplo, e seguindo o manual para usuário para USB
HOST da STMicroelectronics (UM1021), foram selecionadas e adicionadas ao
projeto, as diversas bibliotecas para comunicação USB, listadas no capítulo 5.2.5.
5.4.3 Implementações
Para inicializar as operações com o host USB é chamada na main a
função USB_Init(), apenas uma vez, junto com outras inicializações de tela e touch,
e declarações de variáveis. Outra função necessária, chamada no loop infinito (while
1), é a USB_Function(), essa tem que executar periodicamente para controlar o
63
estado da comunicação e chamar a USBH_Process(), as descrições das funções
estão melhor explicado no capitulo 5.3.
Foi necessário reduzir a frequência de funcionamento da placa
stm32f429 de 180MHz a 168MHz para que o USB pudesse funcionar a 48MHz. Foi
alterado no arquivo System_stm32f4xx.c na parte referente à stm32f429, as
variáveis SystemCoreClock para o valor 168000000 e a PLL_N para 336.
O USBH_Process() ao requisitar o relatório com informações do
teclado, chama a função KEYBRD_Decode() sempre que ocorrer alteração nos
buffers do teclado, essa é responsável por decodifica-lo, e ao final exporta o valor
ASCII na função USR_KEYBRD_ProcessData (uint8_t data) que salva na variável
USB_KEY_DATA.tecla_press.
O primeiro objetivo de piscar um LED com comando do teclado,
utilizou a função GetKey(), chamada no loop da main, essa função lê, zera e retorna
o valor ASCII da USB_KEY_DATA.tecla_press, que é então verifica e se existe
algum valor diferente de zero nela, acende o led.
Partindo desse esqueleto de programa e utilizando a função
Font_DrawChar(), com os argumentos corretos para função explicados no capitulo
5.3, já é possível imprimir um caractere na tela, foi então criada na a função
key_function() para organizar as variáveis e função do teclado. Criada variáveis de
posição x e y para definir o local do início da digitação, e também o deslocamento
horizontal de 11 pixel conforme a largura da impressão e ao final da linha voltar ao
começo na linha seguinte determinado pela altura dos caracteres.
Para adicionar as teclas com comandos foi necessário alterar as
tabelas do KEYBRD_Decode() que agora, além de valores ASCII, identifica
comandos como BackSpace, CapsLock, Enter ,Tab, Esc e setas direcionais. Foi
utilizado valores abaixo de 32 na tabala ASCII para representar e exporta esses
comandos que são interpretados na key_function(), assim dando mais controle sobre
o texto a ser digitado. A única exceção fica com o CapsLock que junto com o shift
sua função deve ser realizada na KEYBRD_Decode(), para definir se a
decodificação do buffer do teclado para ASCII será em maiúsculo ou minúsculo.
Enter, Tab e setas direcionais apenas realizam modificação em x e y, com a devidas
verificação do limite da tela, BackSpace imprime um quadrado na cor do fundo sobre
o caráter anterior, e é capaz retornar para linhas superior de forma a apagar todo
texto parando ao chegar na primeira posição.
64
Figura 5.9: Diagrama das rotinas do projeto.
65
Foi necessário realizar as modificações no processo de
decodificação da informação recebida do teclado para que fosse compatível com o
teclado abnt2, para isso, foi alterado o reconhecimento das posições de diversas
teclas como acentos, colchetes, interrogação, til, etc. E também a inclusão das
posições e dos códigos ASCII das teclas: cê-cedilha, acento agudo e trema. O
grafismo dessa novas tecla precisou ser criado.
Para a implementação da capacidade de acentuar as vogais, foi
criada a função verificaracentos(ascii_code) logo após da função GetKey() e antes
de ser impresso, essa função que funciona em duas passagem na primeira
armazenando o acento e na segunda modificando o valor ASCII conforme a tabela
ASCII estendida, com valores diferentes para vogal acentuada maiúscula e
minúscula e seus possíveis acentos, o grafismo para cada uma desse caracteres
precisou ser feito, descrito no capítulo 5.2.4.
Da forma que as bibliotecas USB para o teclado são feitas e o
processo do USB funciona, o pressionar e segurar a tecla não causa a repetição
constante da mesma, a função KEYBRD_Decode() só é chamada quando ocorre
alteração no buffer do teclado e só exporta quando há uma nova tecla, foi então
criado uma outra função GetKey2() e uma nova variável chamada de
USB_KEY_DATA.tecla_liberada apenas para informar se ocorreu a liberação de
tecla, essa variável é utilizada na key_function(), que passou a possuir um sistema
com um contador para determinar se a tecla está sendo segurada por longo período,
após esse tempo se não for detectada borda de subida, a tecla começa a ser
repetida em curtos períodos até que seja detectado a liberação da tecla.
Por fim, foi adicionado no projeto final, um menu principal que
aparece ao iniciar, para melhor demonstração dos recursos e utilização do teclado, e
disponibilizar algumas opções que podem ser selecionadas com as setas do próprio
teclado ou com um toque na tela.
66
67
6 RESULTADOS OBTIDOS
Os resultados de uma programação de um interface humana devem
além cumprir sua função proposta, devem ser isento de possíveis erros causados
por usuários, para isso teste de com diferentes teclados USB, quantidade de teclas
pressionadas, velocidade de digitação devem ser testados.
6.1 VERIFICAÇÃO DE ERROS
O correto funcionamento do programa passa por um verificação de
erros mais básicos logo que ele é compilado, figura 6.1, evitando erros grosseiros de
programação como digitação incorreta, falta ou excesso de parênteses e chaves,
variáveis inutilizadas, funções repetidas. Em seguida, o código compilado, é gravado
na memória do microcontrolador também ocorre um confirmação do correto
funcionamento da operação.
Figura 6.1: Verificação de erros CoIDE.
Fonte: Próprio autor.
6.2 FUNCIONAMENTO
A energia para funcionamento da placa stm32f429 pode ser
alimentada diretamente com 5V ou pela porta USB de programação, de preferência
por USB que conta com regulação de tensão, foi utilizado ao longo do trabalho, a
saída USB do computado para energiza-la, como também um carregador de celular
e um banco de baterias com saída USB, todo funcionaram sem diferenças.
Ao energizar placa, a inicialização do sistema (clock, tela, USB)
acontece automaticamente, então o processo USB fica a espera de uma conexão
68
mas tudo o que se vê na tela é a mensagem "conecte o teclado", figura 6.2, isso
quando a inicialização ocorre sem problemas, o touch algumas vezes apresentou
problemas na inicialização, sendo necessário remover da energia e plugar
novamente. Foi pensando em retirar o recurso devido a isso.
Ao conectar o receptor sem fio do teclado USB na placa, o programa
então realiza o reconhecimento, enumeração e requisição de classe, então o
processo USB entra em um estado de controle de classe, a mensagem "conecte o
teclado" desaparece e o cursor de texto aparece no topo esquerdo da tela. Neste
momento o teclado já está pronto para uso.
Figura 6.2: Reconhecimento do teclado USB.
Fonte: Próprio autor.
69
A digitação funciona como um editor simples, com todos os
caracteres e pontuação abnt2, podendo acentuar vogais, pular linha, deletar, ativar
CapsLock para digitar maiúsculo ou utilizar shift pressionado, que também serve
para teclas com duas funções. Pressionar e segurar uma tecla causa a repetição
periódica da mesma. O cursor pode ser movido com a teclas direcionais(setas) ou
por um toque na tela sensível.
Figura 6.3: Digitação na placa.
Fonte: Próprio autor.
70
6.3 PROGRAMA
O código em C criado no CoIDE para esse projeto, possui
comentários de linha em linha com explicação de cada função e o motivo, na
tentativa de reduz o tempo para o entendimento das rotinas em usos futuros.
Figura 6.4: Exemplo de código
Fonte: Próprio autor.
O arquivo main.c pode ser verificado no apêndice A, mas
recomendasse utilizar o próprio projeto na Interface coocox devido a organização por
cores, formatação das linhas e explicações sobre as funções ao seleciona-las.
71
7 CONCLUSÃO
Com esse trabalho é possível concluir que o controle de um sistema
embarcado pode ocorrer através de uma porta USB On-The-Go, e com a utilização
de teclados ou outros dispositivos comum no padrão USB. Assim permitindo que
sejam adicionadas uma grande variedade de funções, como envio de comando ou
mensagem em texto, mudança de configuração e parâmetros, controle em tempo
real de dispositivos não autônomos, e em alguns casos substituir a existência de
botões permanentes no produto final devido a capacidade do padrão USB poder ser
removido e conectado a qualquer momento.
Esse projeto realizou com sucesso a comunicação de um
microcontrolador ARM diretamente com o teclado USB, simultaneamente a utilização
de uma tela sensível ao toque, para isso foi utilizado diversas bibliotecas de
fabricante e de terceiros, foi realizada como demonstração de sua capacidade uma
interface de digitação no padrão ABNT2 e menu de opções.
Projetos em programação, desde que feitos de forma organizada
como esse, podem ser reaproveitados em futuros projetos, assim reduzindo o tempo
necessário para desenvolvimento e aumentando qualidade geral do software.
Esperasse que esse trabalho juntamente com a programação já
feita facilite a implementação dessa forma comunicação em microcontroladores, e
que assim adicione recursos em aplicações maiores.
72
73
REFERÊNCIAS
AXELSON, Jan. USB complete: everything you need to develop custom USB peripherals. 3ª edição. Lakeview Research, 2005.
ARM. CMSIS - Cortex Microcontroller Software Interface Standard. 2008 Disponível
em: <http://www.arm.com/about/newsroom/23722.php> Acesso em: 23 julho 2015
BARROS, A. M. de S. ANSI C para quem tem pressa. 24 feb. 2003. Disponível em:
<http://www.dei.isep.ipp.pt/~abarros/docs/ANSI_C.pdf>. Acesso em: 15 setembro 2015.
BEYONDLOGIC. USB in a NutShell. Disponível em:
<http://www.beyondlogic.org/usbnutshell/usb1.shtml> Acesso em: 25 setembro 2015.
LAU, DEREK. USB and PS/2 Multimedia Keyboard Interface. Freescale Semiconductor.
Disponível em: < http://www.nxp.com/files/microcontrollers/doc/ref_manual/DRM014.pdf >
Acesso em: 08 Dezembro 2015.
HEINEMANN, Lars. Effective and Efficient Reuse with Software Libraries. 2012.
Disponível em: < https://www.cqse.eu/publications/2012-effective-and-efficient-reuse-with-
software-libraries.pdf > Acesso em: 23 novembro 2015.
KOPPLIN, Jonh. An Illustrated History of Computers. 2002. Disponível em: <
http://www.computersciencelab.com/ComputerHistory/HistoryPt4.htm> Acesso em: 17
outubro 2015.
LUÍS, Bruno; PACHECO, Carla. Descrição do funcionamento e protocolo de um
teclado(PS/2). 2002. Disponível em: <
https://student.dei.uc.pt/~bluis/arqc2/Arq_Teclado.pdf>. Acesso em: 15 setembro 2015.
MARCHI, Jerusa. Linguagens de Programação. Disponível em:
<http://www.inf.ufsc.br/~olinto/ine5622-cap3.pdf>. Acesso em: 16 setembro 2015.
PHILIPS semiconductors. USB On-The-Go: A Tutorial. 2002 Disponível em:
<http://rogercom.com/CursoOnlineUSB/OTG.pdf > Acesso em: 18 janeiro 2016
PINOUTS. USB Pinout. Disponível em: <http://pinouts.ws/usb-pinout.html> Acesso em: 15
maio 2015.
PUNCHED CARD. Wikipedia, the free encyclopedia. Disponível em:
<https://en.wikipedia.org/wiki/Punched_card> Acesso em: 15 setembro 2015.
REMPLES, Terrence B. USB On-The-Go Interface for Portable Devices.IEEE 2003
Disponível em: <http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1218781>
Acesso em: 18 janeiro 2016.
STMicroelectronics. STM32Cube. Disponível em:
<http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/PF259242> Acesso
em: 17 outrubro 2015.
74
STMicroelectronics. STM32F429 Seminar. Disponível em: < http://wiki.csie.ncku.edu.tw/
embedded/STM32F429-Seminar.pdf > Acesso em: 15 maio 2015.
STMicroelectronics. Reference manual. Disponível em: <http://www.st.com/web/en/
resource/technical/document/reference_manual/DM00031020.pdf> Acesso em: 15 maio
2015.
STMicroelectronics. Cortex-M4 Programming manual. Disponível em:
<http://www.st.com/web/en/resource/technical/document/programming_manual/DM0004698
2.pdf> Acesso em: 15 maio 2015.
STMicroelectronics. STM32F429 User manual. Disponível em: < http://www.st.com/st-
web-ui/static/active/cn/resource/technical/document/user_manual/DM00092920.pdf> Acesso
em: 15 maio 2015.
USB. Device class definition for human interface devices. Disponível em:
<http://www.usb.org/developers/hidpage/HID1_11.pdf> Acesso em: 08 dezembro 2015.
USB. Universal serial bus revision 2.0 specification. Disponível em: <http://www.usb.org
/developers/docs/usb20_docs/#usb20spec> Acesso em: 08 dezembro 2015
ZHIGUI, Lin; DEJUN, Meng; QINGQING, Zhong. Design and Implementation of OTG
Communication System Terminal Based on USB. 2011 Disponível em: <http://ieeexplore
.ieee.org/stamp/stamp.jsp?tp=&arnumber=5997526> Acesso em: 18 janeiro 2016
Zuquim, Ana L. A. P.. Conversão de uma interface serial em USB. Disponível em: <
http://homepages.dcc.ufmg.br/~ana/rt01> Acesso em: 18 agosto 2015.
75
APENDICE A
//Arquivo main.c
#include "main.h"
#include "stm32_ub_lcd_ili9341.h"
#include "stm32_ub_touch_stmpe811.h"
#include "usbh_usr.h"
#include "stm32_ub_font.h"
int main(void)
{
SystemInit(); // Configurações e inicialização do clock
UB_LCD_Init(); // Inicialização LCD
UB_LCD_LayerInit_Fullscreen(); // Inicialização da camadas da tela
UB_LCD_SetLayer_1(); // Inicialização da camadas do fundo
UB_LCD_FillLayer(RGB_COL_WHITE); // Cor do fundo
UB_LCD_SetLayer_2(); // Inicialização da camadas em primeiro plano
UB_LCD_FillLayer(RGB_COL_WHITE); // Cor do primeiro plano
CurrentFrameBuffer=LCD_FRAME_BUFFER + LCD_FRAME_OFFSET; // Controle da tela
aktColor=LCD_COLOR_BLUE; // Variável para armazenar cor de preferência
menu=0; //Programa inicia no menu principal
// Verifica se a inicialização da tela sensível ao toque ocorreu corretamente
if(UB_Touch_Init()!=SUCCESS){
//Imprime mensagem de erro
UB_Font_DrawString(10,28,"Touch error",&Arial_11x20,RGB_COL_WHITE,
RGB_COL_RED);
UB_Font_DrawString(10,46,"Reconecte a energia",&Arial_11x20,
RGB_COL_WHITE,RGB_COL_RED);
while(1){}; //Impede o progresso das demais rotinas
}
USB_HID_HOST_STATUS_t host_status; // Variável para armazenar o estado da
comunicação USB
USB_Init(); // Inicializações para utilizar USB
while(1){ // inicia loop infinito
// Imprime retângulo branco do tamanha da tela(apaga tela)
LCD_DrawFullRect(0, 0, 240, 320, LCD_COLOR_BLACK);
imprimir_menu(); // Imprime grafismo do menu inicial
//--------------------------------------------------------------
while(menu==0) // Enquanto menu==0 o programa fica no menu inicial
76
{
host_status=USB_Function(); // Esta função deve ser chamada
periodicamente para o funcionamento do teclado
// Se o USB não estiver desconectado
if(host_status!=USB_HID_DEV_DETACHED)
menu = arrow_function(); // Chama função que controla o
selecionamento do menu
// Lê informações do touch
UB_Touch_Read();
if(Touch_Data.status==TOUCH_PRESSED) {
if((Touch_Data.yp < 130) && (Touch_Data.yp >= 70)) {
// Verifica limites da região de um botão touch na tela
if((Touch_Data.xp < 200) && (Touch_Data.xp > 50)) {
menu=1; // Se o toque ocorreu muda o estado do
programa
}
}
}
if(menu==1) // menu==1 equivale ao modo de Digitação
{
pos.x = 10; // Posições onde o cursor de digitação começa
pos.y = 10;
// Imprime retângulo branco do tamanha da tela(apaga tela)
LCD_DrawFullRect(0, 0, 240, 320, LCD_COLOR_WHITE);
}
if(menu==2){ // menu==2 equivale ao modo de Opções
// Imprime retângulo branco do tamanha da tela(apaga tela)
LCD_DrawFullRect(0, 0, 240, 320, LCD_COLOR_WHITE);
//Imprime mensagem
UB_Font_DrawString(10,10,"Cor do
texto",&Arial_11x20,aktColor,RGB_COL_WHITE);
}
}
while(menu==1) // menu==1 equivale ao modo de Digitação
{
host_status=USB_Function(); //Esta função deve ser chamada
periodicamente para o funcionamento do teclado
UB_Touch_Read(); //Leitura do Touch
LCD_DrawLine(pos.x,pos.y, 20, LCD_DIR_VERTICAL, RGB_COL_WHITE);
if(Touch_Data.status==TOUCH_PRESSED) {
// Verifica se toque foi na tela(para evitar erros}
if((Touch_Data.yp < 317) && (Touch_Data.yp >= 3)) {
if((Touch_Data.xp < 237) && (Touch_Data.xp > 3)) {
pos.x=Touch_Data.xp;
// Posiciona o cursor sobre o local tocado
pos.y=Touch_Data.yp;
LCD_DrawLine(pos.x,pos.y, 20, LCD_DIR_VERTICAL,
RGB_COL_WHITE);
}
}
}
77
// Se o USB não estiver desconectado
if(host_status!=USB_HID_DEV_DETACHED
//Interpreta todas teclas e funções do teclado, retorna posição do cursor
pos = key_function(pos);
if(host_status==USB_HID_DEV_CONNECTED) //Se o USB for
reconectado
LCD_DrawFullRect(0, 302, 240, 320, LCD_COLOR_WHITE); //Apaga
mensagem
if(host_status==USB_HID_DEV_DETACHED) //Se o USB for desconectado
UB_Font_DrawString(10,302,"Teclado
desconectado",&Arial_11x20,RGB_COL_RED,RGB_COL_WHITE); //Imprime mensagem
}
while(menu==2) // menu==2 equivale ao modo de Opções
{
host_status=USB_Function(); //Esta função deve ser chamada
periodicamente para o funcionamento do teclado
//Se o USB não estiver desconectado
if(host_status!=USB_HID_DEV_DETACHED)
menu = opcoes();
}
}
}
//--------------------------------------------------------------
/**
* @brief Está rotina é chamada para imprimir o menu principal, ela
* apaga a tela completamente e insere retângulos dos botões e textos
* @param Nenhum
* @retval Nenhum
*/
void imprimir_menu(void){
LCD_DrawFullRect(45, 70, 150, 60, RGB_COL_WHITE);
UB_Font_DrawString(65,90,"Digitar",&Arial_11x20,RGB_COL_BLACK,RGB_COL_WHITE);
LCD_DrawFullRect(45, 200, 150, 60, RGB_COL_WHITE);
UB_Font_DrawString(65,220,"Opções",&Arial_11x20,RGB_COL_BLACK,RGB_COL_WHITE);
}
//--------------------------------------------------------------
78
79
ANEXO A
80
81
82