desenvolvimento de um sistema embarcado de comunicação

MATHEUS DANIEL FACCIN

DESENVOLVIMENTO DE UM SISTEMA EMBARCADO DE

COMUNICAÇÃO PADRÃO USB COM

MICROCONTROLADOR ARM.

Londrina 2016





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





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


____________________________________ Prof. Dr. Newton da Silva


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.

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.


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.

http://pt.wikipedia.org/wiki/Interfer%C3%AAncia

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


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


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/.

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.


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.


45

Figura 4.2: STM32F429 componentes atrás.


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


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.


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.


Figura 5.3: Interface para controle dos pinos STM32Cube.


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.


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


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.


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.

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.


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.


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.


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


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.

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;


LCD_DrawFullRect(0, 0, 240, 320, LCD_COLOR_WHITE);

}

if(menu==2){ // menu==2 equivale ao modo de Opções


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


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


//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);

}

//--------------------------------------------------------------

79

ANEXO A

desenvolvimento de um sistema embarcado de comunicação

Documents