sistemas embarcador

Prévia do material em texto

Sistemas Embarcados
Luis Claudio Gambôa Lopes
Agenda
• Primeira aula - 24/02/2018- 3 horas
• Segunda aula - 03/03/2018- 3 horas
• Terceira aula - 10/03/2018- 3 horas
• Quarta aula - 17/03/2018- 3 horas
• Quinta aula - 24/03/2018- 3 horas
• Sexta aula - 07/04/2018- 3 horas
• Sétima aula - 14/04/2018- 3 horas
• Oitava aula - 28/04/2018- 3 horas
• Nona aula - 28/04/2018- 3 horas
24/02/2018 Pós-graduação em Internet das Coisas 2
Conteúdo
1 Primeira Aula - 24/02/2018
I Introdução ao KICAD
I Utilização do KICAD
I Esquemático e PCB
I Captura de Esquemático
I Associação de Footprints
I Criação da PCB
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
24/02/2018 Pós-graduação em Internet das Coisas 3
PRIMEIRA AULA
Captura de esquemático e criação de PCB com o KICAD
24/02/2018 Pós-graduação em Internet das Coisas 4
Introdução ao KICAD
• O KICAD é um conjunto de programas de código livre
multiplataforma (windows/ linux/mac) para captura de
esquemáticos, desenho de placas de circuito impresso
(PCB) e vizualição 3D da placa.
• O site oficial do projeto é o http://kicad-pcb.org/.
• O programa pode ser baixado no endereço
http://kicad-pcb.org/download/.
• O KICAD recebe apoio para seu desenvolvimento de
empresas e instituições como o CERN, Arduino e
raspberry pi foundation http://kicad-pcb.org/about/kicad/ .
• Neste turorial será descrita a instalação e algumas
características do KiCad 4.0.2 para windows.
24/02/2018 Pós-graduação em Internet das Coisas 5
Instalação
Ao executar o instalador será aberta a janela de boas vindas,
basta clicar em next para continuar.
24/02/2018 Pós-graduação em Internet das Coisas 6
Instalação
Na janela seguinte é possível escolher quais componentes
devem ser instalados, por padrão todos já vem selecionados,
basta clicar next para continuar.
24/02/2018 Pós-graduação em Internet das Coisas 7
Instalação
Na próxima janela, é possível escolher onde o KICAD será
instalado, para usar o diretório padrão basta clicar em next
novamente.
24/02/2018 Pós-graduação em Internet das Coisas 8
Instalação
Em sequência será mostrada a janela de progresso da
instalação, basta esperar a instalação ser finalizada.
24/02/2018 Pós-graduação em Internet das Coisas 9
Instalação
Na finalização, basta clicar em Finish para concluir. Se o
checkbox for marcado, você será redirecionado para a página
do Wings3D, um editor de modelos 3D usado para desenhar
novos componentes 3D para o Kicad, para usar o Kicad o
Wings3D não é necessário.
24/02/2018 Pós-graduação em Internet das Coisas 10
Utilização do KICAD
Para iniciar o kicad basta clicar no ícone:
A janela principal de projeto do KICAD será aberta.
24/02/2018 Pós-graduação em Internet das Coisas 11
Utilização do KICAD
Nela são encontradas as principais ferramentas do KICAD
(algumas só são habilitadas após um projeto ser aberto):
Eeschema - Editor de esquemático
Editor de biblioteca de símbolos de esquemático
PcbNew - Editor de placas de circuito impresso
editor de biblioteca de footprints
GerbView - Visualizador de arquivos gerber
Bitmap2Component - Conversor de figuras para
componentes de esquemático ou footprint
Pcb Calculator - Várias ferramentas para projeto de placas
Pi editor - Editor de layout de páginas
24/02/2018 Pós-graduação em Internet das Coisas 12
Utilização do KICAD
A primeira coisa a ser feita é criar ou abrir um projeto. Para
ilustrar o funcionamento será aberto um projeto de exemplo que
já vem junto ao KICAD.
24/02/2018 Pós-graduação em Internet das Coisas 13
Utilização do KICAD
Apos clicar em Open Project na tela principal, abra o arquivo
“C:/Program Files/KiCad/share/kicad/demos/pic_programmer/
pic_programmer.pro” (no Linux:
“/usr/share/kicad/demos/pic_programmer/ pic_programmer.pro”)
24/02/2018 Pós-graduação em Internet das Coisas 14
Utilização do KICAD
Agora na tela de projeto do KICAD é possível ver os arquivos do
projeto de exemplo.
24/02/2018 Pós-graduação em Internet das Coisas 15
Utilização do KICAD
Clicando no arquivo com extensão .sch, será aberto a janela do
Eeschema, o editor de esquemáticos do KICAD. No caso do
projeto de exemplo, é mostrado o equemático do circuito
eletrônico de um gravador de microcontroladores PIC.
24/02/2018 Pós-graduação em Internet das Coisas 16
Utilização do KICAD
Clicando no arquivo com extensão .kicad_pcb, será aberto a
janela do PcbNew, o editor de placas de circuito impresso do
KICAD.
24/02/2018 Pós-graduação em Internet das Coisas 17
Utilização do KICAD
Dentro do PcbNew, é possível abrir o visualizador 3D,
acessando a opção “3D Viewer” no menu “Ver”.
24/02/2018 Pós-graduação em Internet das Coisas 18
Utilização do KICAD
Na janela de visualização 3D é possível visualizar e rotacionar a
placa de circuito impresso, vendo todos os detalhes da posição
dos componentes na placa.
24/02/2018 Pós-graduação em Internet das Coisas 19
Utilização do KICAD
O KICAD ainda possui algumas ferramentas (Pcb calculator)
como o visualizador de código de cores de resistores de acordo
com a precisão.
24/02/2018 Pós-graduação em Internet das Coisas 20
Utilização do KICAD
E uma calculadora de largura da trilha de cobre de acordo com
a corrente e comprimento da trilha.
24/02/2018 Pós-graduação em Internet das Coisas 21
Esquemático e PCB
O processo de projeto de uma placa de circuito impresso (PCI
ou PCB, do inglês printed circuit board), normalmente se
resume a duas etapas no caso de placas simples:
• Captura do esquemático;
• Desenho da PCB.
Para o caso de placas mais complexas outras etapas podem
ser adicionadas, como por exemplo a análise de interferência
eletromagnética entre as trilhas.
24/02/2018 Pós-graduação em Internet das Coisas 22
Esquemático e PCB
O esquemático representa através de símbolos os elementos e
ligações de um circuito eletrônico. Por exemplo, um capacitor
pode ser representado pelos símbolos abaixo no Kicad:
24/02/2018 Pós-graduação em Internet das Coisas 23
Esquemático e PCB
Todos sabemos que na realidade um capacitor não se parece
com seu símbolo gráfico, como podemos comprovar com a
visualização dos modelos de capacitores 3D do Kicad abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 24
Esquemático e PCB
Logo, somente o símbolo do capacitor e seu valor não são
suficientes para desenhar, é preciso saber qual o formato do
capacitor e suas dimensões físicas para poder desenhá-lo na
placa. Essas informações recebem o nome de footprint (cuja
tradução significa “pegada”) que é o desenho de acordo com o
formato e tamanho do elemento. Para capacitores podemos
utilizar por exemplo alguns dos footprints abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 25
Esquemático e PCB
Agora com o entendimento que um esquemático utiliza
símbolos para representar os elementos de um circuito e o
desenho da PCB utiliza footprints para representar os
elementos fica mais claro a diferença entre as duas etapas de
projeto de uma PCB.
24/02/2018 Pós-graduação em Internet das Coisas 26
Captura de Esquemático
Para facilitar o entendimento, vamos utilizar como exemplo um
circuito para acionamento de relé de 5 volts (vendido
normalmente como shield relé). Este circuito permite
microcontroladores e plataformas microcontroladas (Arduino e
outros) acionar uma carga de maior potência (lâmpadas ou
motores por exemplo) através de um relé.
Como o relé normalmente precisa de uma corrente maior do
que a fornecida pelos pinos de um microcontrolador, é utilizado
um transistor para resolver este problema.Além do transistor é
necessário um diodo de proteção junto a bobina do relé e é
usado um LED para indicar se o relé está ligado ou não.
24/02/2018 Pós-graduação em Internet das Coisas 27
Captura de Esquemático
Para confecção desse circuito são necessários os seguintes
componentes:
• 1 resistor 1k 1/8W
• 1 resistor 10k 1/8W
• 1 diodo 1N4148
• 1 LED 3mm
• 1 transistor BC548
• 1 conector header 3
• 2 conector kre 3
• 1 relé de 5V e 2 contatos
Com essas informações podemos começar a captura do
esquemático.
24/02/2018 Pós-graduação em Internet das Coisas 28
Captura de Esquemático
Primeiramente, na janela inicial do Kicad devemos criar um
novo projeto, acessando o menu “Arquivo->New Project->New
Project”, conforme figura abaixo.
24/02/2018 Pós-graduação em Internet das Coisas 29
Captura de Esquemático
Na janela aberta, escolha o diretório onde os arquivos do
projeto serão salvos e dê um nome ao projeto, para este
exemplo foi usado o nome “acionamento”.
24/02/2018 Pós-graduação em Internet das Coisas 30
Captura de Esquemático
Em sequência, devemos abrir o editor de esquemático
Eeschema, clicando no ícone
24/02/2018 Pós-graduação em Internet das Coisas 31
Captura de Esquemático
Na janela principal do Eeschema podemos utilizar a roda do
mouse (mouse wheel) para dar zoom no esquemático, o zoom é
centralizado pelo cursor.
A adição de componentes pode ser feita utilizando o ícone
“place componentes” acessado na barra de ferramentas da
direita ou pelo menu Inserir.
24/02/2018 Pós-graduação em Internet das Coisas 32
Captura de Esquemático
Após clicar no botão de adicionar
componentes deve-se clicar em
qualquer ponto onde se deseja inserir
o componente no esquemático.
Depois do clique é aberta um janela
para a seleção dos componentes. A
busca pode ser feita digitando o nome
do componente ou buscando o
mesmo nas bibliotecas listadas.
Digitando “r” selecionamos o resistor,
clicando no botão ok o elemento é
adicionado no esquemático.
24/02/2018 Pós-graduação em Internet das Coisas 33
Captura de Esquemático
Podemos adicionar os outros elementos (menos o relé ,por
enquanto) conforme quantidade e nome listados abaixo:
Descrição Nome na biblioteca do Kicad Quantidade
Resistor R 2
Diodo D 1
LED LED 1
Transistor BC548 1
Connector 3 vias CONN_01x03 3
24/02/2018 Pós-graduação em Internet das Coisas 34
Captura de Esquemático
Depois de adicionados todos os componentes (exceto o relé), o
esquemático deve ficar conforme a figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 35
Captura de Esquemático
Para o relé, vamos criar um símbolo novo, já que o relé
existente no Kicad não possui a pinagem compatível com o que
iremos utilizar. Para criar um símbolo devemos clicar no ícone
“library editor” ou utilizar o menu Tools. A janela de edição
de símbolo é similar a janela principal.
24/02/2018 Pós-graduação em Internet das Coisas 36
Captura de Esquemático
Podemos criar um componente do
zero clicando no ícone “Create a new
component”
No nosso exemplo vamos criar um
símbolo modificando um já existente,
para isso primeiramente deve ser
selecionada a biblioteca onde está o
símbolo. Isto é feito clicando-se no
ícone “select working library”
Escolha a biblioteca “device” e clique
em ok para continuar.
24/02/2018 Pós-graduação em Internet das Coisas 37
Captura de Esquemático
Clicando no ícone “Load componente from library” escolha
o componente Relay 2RT.
Iremos modificar a pinagem deste componente padrão para
criar um com a pinagem correta para nossa aplicação.
24/02/2018 Pós-graduação em Internet das Coisas 38
Captura de Esquemático
Depois do componente carregado, dê um duplo clique sobre o
nome “RELAY_2RT” para trocar o nome do componente para
“RELE_NOVO”.
24/02/2018 Pós-graduação em Internet das Coisas 39
Captura de Esquemático
Para movimentar vários elementos ao mesmo tempo, clique
com o botão direito e arraste para marcar um retângulo de
seleção, solte o botão e arrastar os componentes para posição
desejada e clique para reposicioná-los.
24/02/2018 Pós-graduação em Internet das Coisas 40
Captura de Esquemático
Reposicione os elementos conforme a figura abaixo para
compor nosso novo componente.
24/02/2018 Pós-graduação em Internet das Coisas 41
Captura de Esquemático
Usando um duplo clique sobre o círculo do pino abra as
propriedades para trocar o número dos pinos:
24/02/2018 Pós-graduação em Internet das Coisas 42
Captura de Esquemático
Troque a numeração dos pinos para ficar como a figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 43
Captura de Esquemático
Com o cursor sobre o pino 3, pressione a teclar “r” 2 vezes para
rotacioná-lo.
24/02/2018 Pós-graduação em Internet das Coisas 44
Captura de Esquemático
Com o cursor sobre o pino 3, pressione a tecla “m” para
movê-lo conforme abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 45
Captura de Esquemático
Faça a mesma coisa com pino 6 para finalizar nosso novo
componente.
24/02/2018 Pós-graduação em Internet das Coisas 46
Captura de Esquemático
Agora devemos salvar o componente em uma nova biblioteca
clicando no ícone “save current component to new library”
Na caixa de diálogo aberta, salve a biblioteca no mesmo
diretório do projeto. Caso desejar, troque o nome da biblioteca,
que no exemplo tem o mesmo nome do componente
“rele_novo.lib”.
24/02/2018 Pós-graduação em Internet das Coisas 47
Captura de Esquemático
Ao salvar aparecerá a mensagem informando da necessidade
de incluir a biblioteca no Eeschema para poder utilizá-la , aperte
ok e feche o editor de componentes.
24/02/2018 Pós-graduação em Internet das Coisas 48
Captura de Esquemático
De volta ao Eeschema, devemos entrar na opção do menu
“Preferences -> Componente Libraries” para incluir a nova
biblioteca criada com o novo relé (Esse é o mesmo
procedimento para utilizar qualquer biblioteca de símbolos de
terceiros no Kicad).
24/02/2018 Pós-graduação em Internet das Coisas 49
Captura de Esquemático
No gerenciador de bibliotecas, clique no botão “Adicionar” para
incluir a nova biblioteca:
24/02/2018 Pós-graduação em Internet das Coisas 50
Captura de Esquemático
Na janela de seleção de arquivos, procure o diretório de projeto
e abra o arquivo da biblioteca criada:
Depois de incluída a biblioteca, pressione ok para fechar a
janela de bibliotecas.
24/02/2018 Pós-graduação em Internet das Coisas 51
Captura de Esquemático
Na janela principal do Eeschema, clique no ícone de adicionar
componentes , e escolha o elemento criado “RELE_NOVO”.
24/02/2018 Pós-graduação em Internet das Coisas 52
Captura de Esquemático
Com todos o elementos, agora é necessário rearranjá-los para
as ligações entre eles serem feitas. Colocando o cursor sobre
um elemento, e apertando a tecla “m” ele pode ser movido. A
tecla “r” pode ser utilizada para rotacionar e a tecla “x” para
espelhar o elemento. Usando esses comandos é possível
arranjar o circuito como na figura abaixo.
24/02/2018 Pós-graduação em Internet das Coisas 53
Captura de Esquemático
As ligações podem ser feitas clicando-se no ícone “place wire”
e clicando nos círculos nos terminais dos componentes.
24/02/2018 Pós-graduação em Internet das Coisas 54
Captura de Esquemático
Conecte todos os elementos como a figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 55
Captura de Esquemático
Intencionalmente foi deixada a
conexão do resistor da base do
transistor desconectada, para que
haja um erro para demonstrarmos o
uso da ferramenta de detecção de
erro.
Antes disso, os componentes
precisam ser nomeados (inicialmente
eles são denominados R?, D?, etc...),
para isso clique no ícone“Annotate
schematic components” . Na
janela que foi aberta, use as opções
padrão e clique no botão “Annotate”:
24/02/2018 Pós-graduação em Internet das Coisas 56
Captura de Esquemático
Na janela aberta em seguida, clique em OK.
24/02/2018 Pós-graduação em Internet das Coisas 57
Captura de Esquemático
Agora todos os componentes estão nomeados, como a figura
abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 58
Captura de Esquemático
Com os componentes nomeados, é possível usar a ferramenta
de detecção de erro ERC, clicando no ícone “perform electrical
rules check“ .
Na janela aberta clique no botão RUN. Clique nos links de texto
em azul para navegar para as partes do circuito que não estão
conectadas ou apresentando problemas (no caso do exemplo, a
base do transistor que ficou desconectada).
24/02/2018 Pós-graduação em Internet das Coisas 59
Captura de Esquemático
Os erros podem ser corrigidos conectando-se os pinos
indicados ou marcando o pino como não conectado clicando no
ícone ”place not-connected flag“ .
Os erros aparecem indicados com setas verdes como na figura
abaixo.
24/02/2018 Pós-graduação em Internet das Coisas 60
Captura de Esquemático
Completando a ligação da base do transistor, basta aperta RUN
na tela da ferramenta de detecção de erro para verificar se está
tudo ok, nenhuma mensagem aparece neste caso como na tela
abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 61
Captura de Esquemático
Fechando a ferramenta de detecção de erro, voltamos ao
circuito que agora está com todas conexões corretas. Agora,
para completar o esquemático basta colocar os valores dos
componentes. Isso pode ser feito colocando-se o cursor sobre o
elemento e apertando a tecla ”v“, como mostrado para o resistor
R1 na figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 62
Captura de Esquemático
Alguns componentes já tem valores como por exemplo o
transistor, LED e o relé. Os demais elementos devem receber o
valor conforme a tabela abaixo:
Elemento Valor
R1 1k
R2 10k
D2 1N4148
P1 Header 1x3
P2 KRE3
P3 KRE3
24/02/2018 Pós-graduação em Internet das Coisas 63
Captura de Esquemático
O esquema completo pode ser visto na figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 64
Captura de Esquemático
É possível adicionar anotações de texto usando a tecla ”t“ e por
exemplo descrever as conexões do conector P1, como na figura
abaixo:
Com o esquemático pronto, podemos salvá-lo e seguir para o
próximo passo.
24/02/2018 Pós-graduação em Internet das Coisas 65
Associação de Footprints
O próximo passo é adicionar o footprint correspondente de cada
componente para podermos desenhar a PCB, isso pode ser
feito clicando no ícone ”Run CvPcb“ para abrir a ferramenta
CvPcb.
Ao abri-lo aparecerá a mensagem abaixo, clique Sim.
24/02/2018 Pós-graduação em Internet das Coisas 66
Associação de Footprints
Isso ocorre porque o elemento Q1 (BC548) já tem um footprint
associado que não foi encontrado, como pode ser constatado
na nova mensagem:
24/02/2018 Pós-graduação em Internet das Coisas 67
Associação de Footprints
A janela principal do CvPcvmostra uma lista com os elementos
e o footprint associado a cada um.
24/02/2018 Pós-graduação em Internet das Coisas 68
Associação de Footprints
Dando um duplo clique nos footprints,na caixa da direita eles
podem ser adicionados ao componente. Como no caso do LED
na figura abaixo, onde foi adicionado o footprint LED-3mm.
24/02/2018 Pós-graduação em Internet das Coisas 69
Associação de Footprints
É possível visualizar o footprint antes de selecioná-lo utilizando
o ícone ”view selected footprint“ , que abre a janela abaixo.
24/02/2018 Pós-graduação em Internet das Coisas 70
Associação de Footprints
Utilizando o ícone ”3d Display“ na janela de visualização do
footprint é possível ver o modelo tridimensional associado ao
footprint:
24/02/2018 Pós-graduação em Internet das Coisas 71
Associação de Footprints
Os footprints são determinados de acordo com os formatos e
dimensões dos componentes físicos disponíveis para
construção da placa. Logo é preciso saber estas informações
antes de projetar a PCB. No caso do nosso exemplo, os
footprints utilizados são para os componentes comuns, ao invés
disso poderiam ser usados componentes SMD, por exemplo.
24/02/2018 Pós-graduação em Internet das Coisas 72
Associação de Footprints
Nome Footprint
D1 LEDs:LED-3MM
D2 Diodes_ThroughHole:Diode_DO-
35_SOD27_Horizontal_RM10
K1 Relays_ThroughHole:Relay_DPDT_IM0
(3,6,7)NS
P1 Pin_Headers:Pin_Header_Straight_1x03
P2 Connect:bornier3
P3 Connect:bornier3
Q1 TO_SOT_Packages_THT:TO-
92_Inline_Narrow_Oval
R1 Resistors_ThroughHole:
Resistor_Horizontal_RM10mm
R2 Resistors_ThroughHole:
Resistor_Horizontal_RM10mm
24/02/2018 Pós-graduação em Internet das Coisas 73
Associação de Footprints
A lista completa é mostrada na janela abaixo, agora basta
salvar, fechar o CvPcb e voltar ao Eeschema.
24/02/2018 Pós-graduação em Internet das Coisas 74
Associação de Footprints
Na tela principal, agora é necessário criar o netlist para a
criação do PCB. Isto pode ser feito pelo ícone ”Generate netlist“
ou pelo menu ”Tools->Generate Net List File“:
24/02/2018 Pós-graduação em Internet das Coisas 75
Associação de Footprints
Na janela aberta, na aba Pcbnew, clique no botão ”Generate“:
24/02/2018 Pós-graduação em Internet das Coisas 76
Associação de Footprints
Clique na opção salvar no diálogo de salvamento de arquivo,
escolhendo o mesmo diretório do projeto.
24/02/2018 Pós-graduação em Internet das Coisas 77
Criação da PCB
Agora podemos passar para o passo final, que é a criação da
placa. No Eeschema utilizando o ícone ou menu
”Tools->Layout printed circuit board“ é possível acessar o
Pcbnew.
24/02/2018 Pós-graduação em Internet das Coisas 78
Criação da PCB
Na tela principal do PcbNew, utilizando o ícone ”Read netlist“
, podemos abrir a janela de carregamento do arquivo de
netlist.
24/02/2018 Pós-graduação em Internet das Coisas 79
Criação da PCB
O netlist pode ser lido utilizando o botão ”Ler Netlist atual“,
depois disso a janela pode ser fechada.
24/02/2018 Pós-graduação em Internet das Coisas 80
Criação da PCB
Agora na tela principal do Pcbnew estão todos os footprintsdos
componentes, mas todos sobrepostos. Marcando o ícone
”Mode:footprint“ e em seguida clicando com o botão direito
na tela pode-se separar os componentes utilizando a opção
”Global Spread and Place -> Spread out All Footprints“:
24/02/2018 Pós-graduação em Internet das Coisas 81
Criação da PCB
Agora todos os footprints dos componentes estão separados
como a figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 82
Criação da PCB
Desenhando uma borda na placa para limitar o posicionamento
pode ser utilizado o ”autoplace“ para posicionar
automaticamente os componentes. Como o circuito é simples, a
alocação dos componentes será feita manualmente, colocando
o cursor sobre os footprints e usando as teclas ”m“ para mover
e ”r“ para rotacionar.
24/02/2018 Pós-graduação em Internet das Coisas 83
Criação da PCB
Reposicione os footprints até que todas as linhas brancas que
indicam as conexões estejam desembaraçadas, como na figura
abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 84
Criação da PCB
Para alterar as propriedades do projeto, acesse o menu ”Regras
de Design->Regras de Design“:
24/02/2018 Pós-graduação em Internet das Coisas 85
Criação da PCB
Para facilitar a construção de placas manuais, utilize uma
largura de trilha de no mínimo 1mm e clique no botão ok.
24/02/2018 Pós-graduação em Internet das Coisas 86
Criação da PCB
As trilhaspodem ser desenhadas manualmente clicando no
ícone ”Add tracks and vias“ e escolhendo a camada no
combobox de camadas .
Para o auto roteamento, devemos escolher a opção ”mode:
tracks“, clicando no ícone
24/02/2018 Pós-graduação em Internet das Coisas 87
Criação da PCB
Agora clicando com o botão direito é possível escolher a opção
no menu ”Auto- rotear -> Selecionar Par de Camadas“:
24/02/2018 Pós-graduação em Internet das Coisas 88
Criação da PCB
Na janela aberta, marque as duas camadas para o mesmo lado
da placa para fazer uma placa de uma camada, como na figura
abaixo.
24/02/2018 Pós-graduação em Internet das Coisas 89
Criação da PCB
Aparecerá uma mensagem de aviso, mas não se preocupe,
apesar de indicar um problema, o roteamento ira funcionar, só
clicar ok.
24/02/2018 Pós-graduação em Internet das Coisas 90
Criação da PCB
Agora utilizando a opção do menu ”Auto-rotear -> Automatically
Route All Footprints“ é possível rotear a placa:
24/02/2018 Pós-graduação em Internet das Coisas 91
Criação da PCB
Resultando na placa roteada:
24/02/2018 Pós-graduação em Internet das Coisas 92
Criação da PCB
Clique no ícone ”DRC“ para utilizar a ferramenta de
verificação de erro, e clique ”iniciar DRC“:
24/02/2018 Pós-graduação em Internet das Coisas 93
Criação da PCB
Como nenhum erro foi encontrado, a placa só precisa da
definição da borda para ficar pronta. Escolha a camada
”Edge.Cuts“ no combo boxde camadas e a ferramenta de
desenhar linhas gráficas clicando no ícone “Add grapich line”
e desenhe uma borda como é mostrado na figura abaixo:
24/02/2018 Pós-graduação em Internet das Coisas 94
Criação da PCB
Utilize o menu “ver -> 3D Viewer” para abrir o visualizador da
placa tridimensional:
24/02/2018 Pós-graduação em Internet das Coisas 95
Criação da PCB
No visualizador 3D clique e arraste o mouse para girar a placa
em visão tridimensional:
24/02/2018 Pós-graduação em Internet das Coisas 96
Criação da PCB
24/02/2018 Pós-graduação em Internet das Coisas 97
Criação da PCB
Para a criação dos arquivos
gerber para confecção da placa,
basta clicar no ícone “plot” .
Em seguida escolher o formato
“Gerber”, marcar as camadas
desejadas e clicar no botão
plotar e em seguida no botão
“GenerateDrillFile”. Os arquivos
gerado podem ser testados na
ferramenta gerberview do Kicad
utilizando o ícone .
24/02/2018 Pós-graduação em Internet das Coisas 98
Criação da PCB
Para utilização de métodos
térmicos, o desenho da placa
pode ser obtido da mesma
maneira, apenas utilizando a
opção “PDF” ao invés de
“Gerber”. Desmarque a opção
“Exclude PCB edge layer from
others layer” para a margem
aparecer em todos os pdfs e
facilitar o posicionamento.
24/02/2018 Pós-graduação em Internet das Coisas 99
Criação da PCB
Com isso concluímos o nosso tutorial, onde o objetivo foi
mostrar como utilizar a ferramenta Kicad para criar uma PCB.
Claro que o Kicad possui muito mais recursos e opções do que
foi descrito, mas esse tutorial descreve o básico para poder
começar a utilizar o Kicad.
24/02/2018 Pós-graduação em Internet das Coisas 100
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
I Plataforma
LAUNCHXL-CC2650
I IDE Code Composer Studio -
CCS
I Compilando a Biblioteca
CC26xxware
I Compilando um Projeto
Simples
I Entendendo o Programa
I Depuração do Projeto
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
03/03/2018 Pós-graduação em Internet das Coisas 101
SEGUNDA AULA
LAUNCHXL-CC2650, Code Composer Studio, biblioteca
CC26xxware, projeto simples e depuração.
03/03/2018 Pós-graduação em Internet das Coisas 102
Plataforma LAUNCHXL-CC2650
03/03/2018 Pós-graduação em Internet das Coisas 103
CC2650
• Descrição
• Datasheet
• User guides
03/03/2018 Pós-graduação em Internet das Coisas 104
Ambiente de desenvolvimento integrado - IDE
(Versão modificada do Eclipse)
Download do CCS
03/03/2018 Pós-graduação em Internet das Coisas 105
Instalação CCS
Para o CC2650 é necessário apenas o suporte ao SimpleLink
CC26xx.
03/03/2018 Pós-graduação em Internet das Coisas 106
Instalação CC26xxware
biblioteca CC26xxware
• Atualmente passou a ser distribuída como parte do
TI-RTOS.
• Documentação de referência para programação
Por razões de compatibilidade, vamos usar a versão levemente
modificada da biblioteca utilizada no sistema operacional
Contiki.
Instalação
mkdir ~/workspace_v7
cd ~/workspace_v7
git clone https://github.com/contiki-os/cc26xxware.git
03/03/2018 Pós-graduação em Internet das Coisas 107
Escolhendo o Workspace
Ao iniciar o CCS possibilita a escolha de um diretório de
trabalho onde serão salvos os projetos.
03/03/2018 Pós-graduação em Internet das Coisas 108
Criando um Novo Projeto de Biblioteca
03/03/2018 Pós-graduação em Internet das Coisas 109
Configurações do Projeto
• Target: SimpleLink Wireless MCU CC2650F128
• Project Name: driverlib
• Compiler Version: GNU
• Project template: Empty project
03/03/2018 Pós-graduação em Internet das Coisas 110
Configurações do Projeto
• Output Type: Library
03/03/2018 Pós-graduação em Internet das Coisas 111
Adicionando os Arquivos da Biblioteca
03/03/2018 Pós-graduação em Internet das Coisas 112
Selecionando os Arquivos
Pasta: $USER/workspace_v7/cc26xxware/driverlib
03/03/2018 Pós-graduação em Internet das Coisas 113
Importação dos Arquivos
03/03/2018 Pós-graduação em Internet das Coisas 114
Desativando a Auto-inclusão de
Cabeçalhos
03/03/2018 Pós-graduação em Internet das Coisas 115
Modificando as Propriedades do Projeto
03/03/2018 Pós-graduação em Internet das Coisas 116
Adicionando o Caminho dos
Arquivos de Cabeçalho
${WORKSPACE_LOC}/cc26xxware/
03/03/2018 Pós-graduação em Internet das Coisas 117
Compilando a Biblioteca CC26xxware
03/03/2018 Pós-graduação em Internet das Coisas 118
Compilando a Biblioteca CC26xxware
Quando finalizada a compilação, a mensagem abaixo indica
que a biblioteca foi criada:
Finished building target: "libdriverlib.a"
**** Build Finished ****
03/03/2018 Pós-graduação em Internet das Coisas 119
Criando um Novo Projeto
03/03/2018 Pós-graduação em Internet das Coisas 120
Configuração do Projeto
• Target: SimpleLink Wireless MCU CC2650F128
• Project Name: simples
• Compiler Version: GNU
• Output File: Executable
03/03/2018 Pós-graduação em Internet das Coisas 121
Configuração do Projeto
• Project template: Empty project (with main.c)
03/03/2018 Pós-graduação em Internet das Coisas 122
Adicionando uma Pasta ao Projeto
03/03/2018 Pós-graduação em Internet das Coisas 123
Configurando o Nome da Pasta
Nome da pasta: Source
03/03/2018 Pós-graduação em Internet das Coisas 124
Organizando os Arquivos na Pasta
Os arquivos podem ser arrastados para as pastas para serem
organizados.
03/03/2018 Pós-graduação em Internet das Coisas 125
Adicionando Arquivos
03/03/2018 Pós-graduação em Internet das Coisas 126
Selecionando o Arquivo de Configuração
Adicionar o arquivo com as funções de inicialização da
biblioteca:
$USER/workspace_v7/cc26xxware/startup_files/startup_gcc.c
03/03/2018 Pós-graduação em Internet das Coisas 127
Criando um Novo Arquivo
03/03/2018 Pós-graduação em Internet das Coisas 128
Selecionando o Nome do Arquivo
Nome do Arquivo: Board.h
03/03/2018 Pós-graduação em Internet das Coisas 129
Atualizando o Conteúdo dos Arquivos
Copie o conteúdo para os arquivos:
• Board.h - Definições de configuraçãoda placa
• main.c - Exemplo simples para piscar os LEDs placa
03/03/2018 Pós-graduação em Internet das Coisas 130
Configurando as Propriedades
03/03/2018 Pós-graduação em Internet das Coisas 131
Adicionando o Projeto driverlib como
Dependência
03/03/2018 Pós-graduação em Internet das Coisas 132
Adicionando o Caminho dos Arquivos de
Cabeçalho
${WORKSPACE_LOC}/cc26xxware/
03/03/2018 Pós-graduação em Internet das Coisas 133
Adicionando no Linker a Biblioteca e o
Caminho
libdriverlib.a
${workspace_loc:/driverlib/Debug}
03/03/2018 Pós-graduação em Internet das Coisas 134
Compilando um projeto simples
03/03/2018 Pós-graduação em Internet das Coisas 135
Entendendo o Programa
#include <stdint.h>
#include <stdbool.h>
/* Example/Board Header files */
#include "Board.h"
#include "driverlib/prcm.h" //peripheral power
#include "driverlib/sys_ctrl.h" //cpu delay
//*****************************************************************************
//
// Blink the on-board LEDs.
//
//*****************************************************************************
int main(void)
{
/* Disable global interrupts */
IntMasterDisable();
// Turn on the PERIPH PD
PRCMPowerDomainOn(PRCM_DOMAIN_PERIPH);
while (PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON);
// Enable GPIO peripheral
PRCMPeripheralRunEnable(PRCM_PERIPH_GPIO);
/* Apply settings and wait for them to take effect */
PRCMLoadSet();
while (!PRCMLoadGet());
03/03/2018 Pós-graduação em Internet das Coisas 136
Entendendo o Programa
// Enable the GPIO pin for the LEDs. Set the direction as output
IOCPinTypeGpioOutput(BOARD_IOID_LED_1);
IOCPinTypeGpioOutput(BOARD_IOID_LED_2);
// Loop forever.
while (1)
{
// Turn on the LED.
GPIO_setDio(BOARD_IOID_LED_1);
GPIO_clearDio(BOARD_IOID_LED_2);
//
// Delay for one second.
//
CPUdelay((SysCtrlClockGet() / 3));
// Turn off the LED.
GPIO_clearDio(BOARD_IOID_LED_1);
GPIO_setDio(BOARD_IOID_LED_2);
// Delay for one second.
CPUdelay((SysCtrlClockGet() / 3));
}
}
03/03/2018 Pós-graduação em Internet das Coisas 137
Exercícios
2.1- Procure na Referência para programação a descrição das
funções CPUdelay() e SysCtrlClockGet().
03/03/2018 Pós-graduação em Internet das Coisas 138
Ativando o Modo de Depuração
03/03/2018 Pós-graduação em Internet das Coisas 139
Executando o Programa
03/03/2018 Pós-graduação em Internet das Coisas 140
Pausando o Programa
03/03/2018 Pós-graduação em Internet das Coisas 141
Executando o Programa Passo a Passo
03/03/2018 Pós-graduação em Internet das Coisas 142
Terminando a Depuração
03/03/2018 Pós-graduação em Internet das Coisas 143
Configurando as Propriedades
03/03/2018 Pós-graduação em Internet das Coisas 144
Alterando as opções de Otimização
03/03/2018 Pós-graduação em Internet das Coisas 145
Exercícios
2.2- Rode o programa passo a passo depois de desligar a
Otimização.
2.3- Copie o projeto “simples” com o novo nome de “botoes” e
crie um programa que acenda cada LED de acordo com o
acionamento de cada botão. Utilize as funções:
• IOCPinTypeGpioInput - Para configurar pino como entrada
• IOCIOPortPullSet - Para ligar o Pull-Up dos pinos
• GPIO_readDio - Para ler o valor dos pinos
03/03/2018 Pós-graduação em Internet das Coisas 146
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
I ADC
I PWM
I Serial
I 1◦ Trabalho
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
10/03/2018 Pós-graduação em Internet das Coisas 147
TERCEIRA AULA
Utilização dos periféricos do CC2650: ADC, PWM, Serial e
Timers
10/03/2018 Pós-graduação em Internet das Coisas 148
ADC
Cabeçalho:
#include "driverlib/aux_adc.h"
Configuração:
//ADC INPUT
IOCPinTypeGpioInput (IOID_23); //Analog channel 7
IOCIOPortPullSet (IOID_23, IOC_NO_IOPULL);
AONWUCAuxWakeupEvent (AONWUC_AUX_WAKEUP);
while (!(AONWUCPowerStatusGet () & AONWUC_AUX_POWER_ON));
AUXWUCClockEnable (
AUX_WUC_ADI_CLOCK | AUX_WUC_ANAIF_CLOCK | AUX_WUC_SMPH_CLOCK);
while (AUXWUCClockStatus (
AUX_WUC_ADI_CLOCK | AUX_WUC_ANAIF_CLOCK | AUX_WUC_SMPH_CLOCK)
!= AUX_WUC_CLOCK_READY);
AUXADCSelectInput (ADC_COMPB_IN_AUXIO7);
AUXADCEnableSync (AUXADC_REF_FIXED, AUXADC_SAMPLE_TIME_1P37_MS,
AUXADC_TRIGGER_MANUAL);
10/03/2018 Pós-graduação em Internet das Coisas 149
ADC
Medição:
int val, adj_val, adj_mv;
AUXADCGenManualTrigger ();
val = AUXADCReadFifo ();
adj_val = AUXADCAdjustValueForGainAndOffset (val,
AUXADCGetAdjustmentGain (AUXADC_REF_FIXED),
AUXADCGetAdjustmentOffset (AUXADC_REF_FIXED));
adj_mv = AUXADCValueToMicrovolts (AUXADC_FIXED_REF_VOLTAGE_NORMAL, adj_val);
10/03/2018 Pós-graduação em Internet das Coisas 150
Exercícios
3.1- Copie o projeto “simples” com o novo nome de “adc” e crie
um programa que faça uma medição analógica utilizando o
conversor ADC.
3.2- Utilize um breakpoint para visualizar o resultado da
conversão.
3.3- Adicione as variáveis na janela de expressões e modifique
o comportamento do breakpoint para só atualizar (Update View)
ao invés de parar o programa.
10/03/2018 Pós-graduação em Internet das Coisas 151
TIMER/PWM
Cabeçalho:
#include "driverlib/timer.h" //timers
Configuração:
#define freq 1000
unsigned int load;
// Enable TIMER peripheral
PRCMPeripheralRunEnable (PRCM_PERIPH_TIMER0);
/* Apply settings and wait for them to take effect */
PRCMLoadSet ();
while (!PRCMLoadGet ());
TimerConfigure (GPT0_BASE, TIMER_CFG_A_PWM | TIMER_CFG_SPLIT_PAIR);
/* Drive the I/O ID with GPT0 / Timer A */
IOCPortConfigureSet (BOARD_IOID_LED_1, IOC_PORT_MCU_PORT_EVENT0,
IOC_STD_OUTPUT);
10/03/2018 Pós-graduação em Internet das Coisas 152
TIMER/PWM
Continuação da configuração:
load = (SysCtrlClockGet () / freq);
TimerLoadSet (GPT0_BASE, TIMER_A, load);
TimerMatchSet (GPT0_BASE, TIMER_A, load / 2);
/* Start */
TimerEnable (GPT0_BASE, TIMER_A);
10/03/2018 Pós-graduação em Internet das Coisas 153
TIMER/PWM
Acionamento:
unsigned int duty=30; // saída a 30%
TimerMatchSet (GPT0_BASE, TIMER_A, load * duty / 100);
10/03/2018 Pós-graduação em Internet das Coisas 154
Exercícios
3.4- Copie o projeto “simples” com o novo nome de “pwm” e crie
um programa que faça o brilho dos LEDs variarem de 0% a
100% e em seguida de 100% a 0% repetindo indefinidamente
esse comportamento, sendo o LED vermelho acesso
inversamente ao verde (use o parâmetro IOC_IOMODE_INV na
função IOCPortConfigureSet ). Utilize um atraso para que a
variação seja visível.
10/03/2018 Pós-graduação em Internet das Coisas 155
Serial
Cabeçalho:
#include "driverlib/uart.h" //uart
Configuração:
/* Power on the SERIAL PD */
PRCMPowerDomainOn (PRCM_DOMAIN_SERIAL);
while (PRCMPowerDomainStatus (PRCM_DOMAIN_SERIAL) != PRCM_DOMAIN_POWER_ON);
/* Enable UART clock in active mode */
PRCMPeripheralRunEnable (PRCM_PERIPH_UART0);
PRCMLoadSet ();
while (!PRCMLoadGet ());
// Make sure the peripheral is disabled
UARTDisable (UART0_BASE);
// Make sure the TX pin is output / high before assigning it to
// UART control to avoid falling edge glitches
IOCPinTypeGpioOutput (BOARD_IOID_UART_TX);
GPIO_setDio (BOARD_IOID_UART_TX);
10/03/2018 Pós-graduação em Internet das Coisas 156
Serial
Continuação da configuração:
//Map UART signals to the correct GPIO pins and configure them as
//hardware controlled.
IOCPinTypeUart (UART0_BASE, BOARD_IOID_UART_RX, BOARD_IOID_UART_TX,
BOARD_IOID_UART_CTS, BOARD_IOID_UART_RTS);
/* Configure the UART for 115,200, 8-N-1 operation. */
UARTConfigSetExpClk (UART0_BASE, SysCtrlClockGet (), 115200,
(UART_CONFIG_WLEN_8| UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
/* Enable FIFOs */
UARTFIFOEnable(UART0_BASE);
/* Enable UART */
UARTEnable(UART0_BASE);
10/03/2018 Pós-graduação em Internet das Coisas 157
Serial
Utilização:
//enviar
UARTCharPut (UART0_BASE, 'O');
UARTCharPut (UART0_BASE, 'k');
UARTCharPut (UART0_BASE, '\r');
UARTCharPut (UART0_BASE, '\n');
//receber
if (UARTCharsAvail (UART0_BASE))
{
UARTCharPut (UART0_BASE, 'R');
UARTCharPut (UART0_BASE, ':');
UARTCharPut (UART0_BASE, ' ');
while (UARTCharsAvail (UART0_BASE))
{
UARTCharPut (UART0_BASE, UARTCharGet (UART0_BASE));
}
UARTCharPut (UART0_BASE, '\r');
UARTCharPut (UART0_BASE, '\n');
}
10/03/2018 Pós-graduação em Internet das Coisas 158
Exercícios
3.5- Crie uma função void UARTPuts(const char* str) que envie
uma string pela porta serial.
3.6- Copie o projeto “simples” com o novo nome de “serial” e
crie um programa que envie pela serial as palavras “ligado” e
“desligado” (utilizando a função UARTPuts criada no exercício
anterior) quando forem recebidas as letras “l” e “d”
respectivamente.
10/03/2018 Pós-graduação em Internet das Coisas 159
1◦ Trabalho
Implemente o suporte ao protocolo descrito no arquivo serial.c sem
modifica-lo no CC2650. Implemente o códigos das seguintes funções:
void Serial_print (const char *str)
void Serial_println(const char *str)
int Serial_available(void)
void Serial_readStringUntil(char *str, char end, int max)
int digitalRead(char pin)
void digitalWrite(char pin, char value)
void analogWrite(char pin,unsigned char value)
int analogRead(char pin)
void delay(int ms)
Arquivo com as definições das funções: funcoes.c
Os pinos que devem ser utilizados no trabalho são:
• 7 - Saida Digital - LED verde
• 13 - Entrada Digital - Chave esquerda
• 6 - Saida Analógica - LED vermelho
• 23 - Entrada Analógica - ADC
10/03/2018 Pós-graduação em Internet das Coisas 160
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
I Monitor de Bateria e
Temperatura
I Interrupção do Timer
I Interrupção do System Tick
I Interrupção dos Pinos
I Interrupção da Serial
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
17/03/2018 Pós-graduação em Internet das Coisas 161
QUARTA AULA
Monitor de Bateria e Temperatura. Utilização das interrupções
dos periféricos do CC2650: Pinos, Serial e Timers.
17/03/2018 Pós-graduação em Internet das Coisas 162
Monitor de Bateria e Temperatura
Cabeçalho:
1 #include "driverlib/aon_batmon.h"
Configuração:
1 AONBatMonEnable();
2 // Loop forever.
3 while (1)
4 {
5 if(AONBatMonNewBatteryMeasureReady())
6 {
7 int32_t valb=AONBatMonBatteryVoltageGet();
8 valb=(valb * 125) >> 5;
9 ...
10 }
11 if(AONBatMonNewTempMeasureReady())
12 {
13 int32_t valt=AONBatMonTemperatureGetDegC();
14 ...
15 }
16 }
17/03/2018 Pós-graduação em Internet das Coisas 163
Exercícios
4.1- Copie o projeto “serial” com o novo nome de
“batmon_serial” e crie um programa que envie pela serial os
valores da bateria e da temperatura toda vez que ocorrer uma
mudança em um dos valores.
17/03/2018 Pós-graduação em Internet das Coisas 164
Interrupção do Timer
Cabeçalho:
1 #include "driverlib/timer.h" //timers
2 void Timer0IntHandler(void);
Configuração:
1 // Enable TIMER peripheral
2 PRCMPeripheralRunEnable(PRCM_PERIPH_TIMER0);
3 /* Apply settings and wait for them to take effect */
4 PRCMLoadSet();
5 while (!PRCMLoadGet());
6 /* enable global interrupts */
7 IntMasterEnable();
8 /* Configure the TIMER_A as 32-bit periodi timer.*/
9 TimerConfigure(GPT0_BASE, TIMER_CFG_PERIODIC);
10 TimerLoadSet(GPT0_BASE, TIMER_A, SysCtrlClockGet());
17/03/2018 Pós-graduação em Internet das Coisas 165
Interrupção do Timer
Continuação da configuração:
11 /*Setup the interrupts for the timer timeouts*/
12 IntEnable(INT_GPT0A);
13 TimerIntEnable(GPT0_BASE, TIMER_TIMA_TIMEOUT);
14 TimerIntRegister(GPT0_BASE, TIMER_A,Timer0IntHandler );
15 /* Enable the timers.*/
16 TimerEnable(GPT0_BASE, TIMER_A);
17 // Loop forever.
18 while (1)
19 {
20 }
17/03/2018 Pós-graduação em Internet das Coisas 166
Interrupção do Timer
Rotina de serviço de interrupção:
1 // The interrupt handler for the first timer interrupt.
2 void
3 Timer0IntHandler(void)
4 {
5 // Clear the timer interrupt.
6 TimerIntClear(GPT0_BASE, TIMER_TIMA_TIMEOUT);
7 }
17/03/2018 Pós-graduação em Internet das Coisas 167
Exercícios
4.2- Copie o projeto “simples” com o novo nome de “int_timer” e
crie um programa que pisque o LED vermelho da placa a cada
0,5 segundos utilizando a interrupção do timer0. Mantenha o
LED verde piscando a cada 1 segundo no loop principal.
4.3- Adicione ao exercício anterior a configuração e a
interrupção do timer1 para piscar o LED verde a cada 2
segundos. Deixe o loop principal vazio.
17/03/2018 Pós-graduação em Internet das Coisas 168
Interrupção do System Tick
Cabeçalho:
1 #include "driverlib/systick.h"
2 void SysTickIntHandler(void);
3 uint32_t milis=0;
Configuração:
1 /* enable global interrupts */
2 IntMasterEnable();
3 SysTickIntRegister(SysTickIntHandler) ;
4 SysTickIntEnable();
5 SysTickPeriodSet(SysCtrlClockGet()/1000); //1 msec
6 SysTickEnable();
7 // Loop forever.
8 while (1){
9 if(milis > 1000){
10 milis=0;
11 GPIO_toggleDio (BOARD_IOID_LED_1);
12 }
13 }
17/03/2018 Pós-graduação em Internet das Coisas 169
Interrupção do System Tick
Rotina de serviço de interrupção:
1 void SysTickIntHandler(void)
2 {
3 milis++;
4 }
17/03/2018 Pós-graduação em Internet das Coisas 170
Exercícios
4.4- Copie o projeto “simples” com o novo nome de “int_systick”
e crie um programa que pisque o LED vermelho da placa a
cada 2 segundos e o LED verde a cada 3 segundos utilizando a
variável milis atualizada pela interrupção do System Tick.
17/03/2018 Pós-graduação em Internet das Coisas 171
Interrupção dos Pinos
Cabeçalho:
1 void IOCIntHandler(void);
Configuração:
1 IOCPinTypeGpioInput (BOARD_IOID_KEY_LEFT);
2 IOCIOPortPullSet (BOARD_IOID_KEY_LEFT, IOC_IOPULL_UP);
3 IOCPinTypeGpioInput (BOARD_IOID_KEY_RIGHT);
4 IOCIOPortPullSet (BOARD_IOID_KEY_RIGHT, IOC_IOPULL_UP);
5 /* enable global interrupts */
6 IntMasterEnable();
7 IOCIOIntSet(BOARD_IOID_KEY_LEFT,IOC_INT_ENABLE,IOC_FALLING_EDGE);
8 IOCIOIntSet(BOARD_IOID_KEY_RIGHT,IOC_INT_ENABLE,IOC_FALLING_EDGE);
9 IntEnable(INT_AON_GPIO_EDGE);
10 IOCIntEnable(BOARD_IOID_KEY_LEFT);
11 IOCIntEnable(BOARD_IOID_KEY_RIGHT);
12 IOCIntRegister (IOCIntHandler );
13 // Loop forever.
14 while (1){
15 }
17/03/2018 Pós-graduação em Internet das Coisas 172
Interrupção dos Pinos
Rotina de serviço de interrupção:
1 void
2 IOCIntHandler(void)
3 {
4 if(IOCIntStatus(BOARD_IOID_KEY_LEFT))
5 {
6 // Clear the timer interrupt.
7 IOCIntClear (BOARD_IOID_KEY_LEFT);
8 }
9 if(IOCIntStatus(BOARD_IOID_KEY_RIGHT))
10 {
11 // Clear the timer interrupt.
12 IOCIntClear (BOARD_IOID_KEY_RIGHT);
13 }
14 }
17/03/2018 Pós-graduação em Internet das Coisas 173
Exercícios
4.5- Copie o projeto “simples” com o novo nome de “int_chaves”
e crie um programa que troque o estado do LED vermelho
quando a chave direita for pressionada e o do LED verde
quando a chave esquerda for liberada utilizando interrupção.
17/03/2018 Pós-graduação em Internet das Coisas 174
Interrupção da Serial
Cabeçalho:
1 #include "driverlib/uart.h" //uart
2 void UART0IntHandler(void);
Configuração:
1 /* Disable global interrupts */
2 IntMasterDisable ();
3 /* Power on the SERIAL PD */
4 PRCMPowerDomainOn (PRCM_DOMAIN_SERIAL);
5 while (PRCMPowerDomainStatus (PRCM_DOMAIN_SERIAL) !=
6 PRCM_DOMAIN_POWER_ON);
7 /* Enable UART clock in activemode */
8 PRCMPeripheralRunEnable (PRCM_PERIPH_UART0);
9 PRCMLoadSet ();
10 while (!PRCMLoadGet ());
11 /* Make sure the peripheral is disabled */
12 UARTDisable (UART0_BASE);
17/03/2018 Pós-graduação em Internet das Coisas 175
Interrupção da Serial
Continuação da configuração:
13 /* Make sure the TX pin is output high before assigning
14 it to UART control to avoid falling edge glitches*/
15 IOCPinTypeGpioOutput (BOARD_IOID_UART_TX);
16 GPIO_setDio (BOARD_IOID_UART_TX);
17 /* Map UART signals to the correct GPIO pins and configure
18 them as hardware controlled. */
19 IOCPinTypeUart (UART0_BASE, BOARD_IOID_UART_RX, BOARD_IOID_UART_TX,
20 BOARD_IOID_UART_CTS, BOARD_IOID_UART_RTS);
21 /* Configure the UART for 115,200, 8-N-1 operation. */
22 UARTConfigSetExpClk (UART0_BASE, SysCtrlClockGet (), 115200,
23 (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
24 UART_CONFIG_PAR_NONE));
25 /* Generate an RX interrupt at FIFO 1/8 full.
26 We don't really care about the TX interrupt*/
27 UARTFIFOLevelSet (UART0_BASE, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
28 /* Enable FIFOs */
29 UARTFIFOEnable(UART0_BASE);
17/03/2018 Pós-graduação em Internet das Coisas 176
Interrupção da Serial
Continuação da configuração:
30 /* enable global interrupts */
31 IntMasterEnable();
32 IntEnable(INT_UART0_COMB);
33 UARTIntEnable(UART0_BASE,UART_INT_RX | UART_INT_RT);
34 UARTIntRegister (UART0_BASE,UART0IntHandler );
35 UARTEnable(UART0_BASE);
36 // Loop forever.
37 while (1)
38 {
39 }
17/03/2018 Pós-graduação em Internet das Coisas 177
Interrupção da Serial
Rotina de serviço de interrupção:
1 void
2 UART0IntHandler(void)
3 {
4 while (UARTCharsAvail (UART0_BASE))
5 {
6 //Lê buffer (reseta condição que gerou a interrupção)
7 UARTCharPut (UART0_BASE, UARTCharGet (UART0_BASE));
8 }
9 // Clear the timer interrupt.
10 UARTIntClear(UART0_BASE,UART_INT_RX | UART_INT_RT);
11 }
17/03/2018 Pós-graduação em Internet das Coisas 178
Exercícios
4.6- Copie o projeto “simples” com o novo nome de “int_serial” e
crie um programa que troque o estado do LED vermelho
quando ocorrer uma interrupção por recepção da porta serial.
17/03/2018 Pós-graduação em Internet das Coisas 179
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
I Interrupção do ADC
I Arquitetura de Software
Embarcado
I Round Robin
I Round Robin com
Interrupções
I Round Robin com
Interrupções e Fila de
Funções
I 2◦ Trabalho
I Sistema Operacional de
Tempo Real
I Conclusão
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
24/03/2018 Pós-graduação em Internet das Coisas 180
QUINTA AULA
Utilização das interrupções do ADC do CC2650. Arquitetura de
Software Embarcado.
24/03/2018 Pós-graduação em Internet das Coisas 181
Interrupção do ADC
Cabeçalho:
1 #include "driverlib/aux_adc.h"
2 #include "driverlib/interrupt.h"
3 #include "inc/hw_aux_evctl.h"
4 void ADCIntHandler(void);
5 int val, adc_fim=0;
Configuração:
1 //ADC INPUT
2 IOCPinTypeGpioInput (IOID_23); //Analog channel 7
3 IOCIOPortPullSet (IOID_23, IOC_NO_IOPULL);
4 AONWUCAuxWakeupEvent (AONWUC_AUX_WAKEUP);
5 while (!(AONWUCPowerStatusGet () & AONWUC_AUX_POWER_ON));
6 AUXWUCClockEnable (
7 AUX_WUC_ADI_CLOCK | AUX_WUC_ANAIF_CLOCK | AUX_WUC_SMPH_CLOCK);
8 while (AUXWUCClockStatus (
9 AUX_WUC_ADI_CLOCK | AUX_WUC_ANAIF_CLOCK | AUX_WUC_SMPH_CLOCK)
10 != AUX_WUC_CLOCK_READY);
11 AUXADCSelectInput (ADC_COMPB_IN_AUXIO7);
24/03/2018 Pós-graduação em Internet das Coisas 182
Interrupção do ADC
Continuação da configuração:
12 AUXADCEnableSync (AUXADC_REF_FIXED, AUXADC_SAMPLE_TIME_1P37_MS,
13 AUXADC_TRIGGER_MANUAL);
14 /* enable global interrupts */
15 IntMasterEnable();
16 IntEnable(INT_AUX_ADC_IRQ);
17 IntRegister(INT_AUX_ADC_IRQ, ADCIntHandler );
18 // Loop forever.
19 int adj_val, adj_mv;
20 AUXADCGenManualTrigger ();
21 while (1){
22 if(adc_fim)
23 {
24 adc_fim=0;
25 adj_val = AUXADCAdjustValueForGainAndOffset (
26 val,AUXADCGetAdjustmentGain (AUXADC_REF_FIXED),
27 AUXADCGetAdjustmentOffset (AUXADC_REF_FIXED));
28 adj_mv = AUXADCValueToMicrovolts (AUXADC_FIXED_REF_VOLTAGE_NORMAL,
29 adj_val);
30 AUXADCGenManualTrigger ();
31 }
32 }
24/03/2018 Pós-graduação em Internet das Coisas 183
Interrupção do ADC
Rotina de serviço de interrupção:
1 void
2 ADCIntHandler(void)
3 {
4 uint32_t intStatus;
5 /* Get the status of the ADC_IRQ line and ADC_DONE */
6 intStatus = HWREG(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUFLAGS) &
7 (AUX_EVCTL_EVTOMCUFLAGS_ADC_IRQ | AUX_EVCTL_EVTOMCUFLAGS_ADC_DONE);
8 if (intStatus & AUX_EVCTL_EVTOMCUFLAGS_ADC_DONE)
9 {
10 //Lê buffer (reseta condição que gerou a interrupção)
11 val = AUXADCReadFifo();
12 }
13 /* Clear the ADC_IRQ flag if it triggered the ISR */
14 HWREG(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUFLAGSCLR) = intStatus;
15 adc_fim=1;
16 }
24/03/2018 Pós-graduação em Internet das Coisas 184
Exercícios
5.1- Copie o projeto “serial” com o novo nome de “int_adc” e
crie um programa que utilize a interrupção do ADC para medir
os valores de um canal, faça a média de 10 amostras e envie o
resultado pela porta serial continuamente.
24/03/2018 Pós-graduação em Internet das Coisas 185
Arquitetura de Software Embarcado
• Uma arquitetura de software fornece a estrutura geral de
uma aplicação embarcada independente da computação
real a ser realizada
• A escolha da arquitetura afeta questões como:
• tempo de desenvolvimento / probabilidade de defeitos de
software
• capacidade de resposta e latência
• tamanho de código/complexidade
• Regra geral:
• Utilizar a arquitetura mais simples possível que forneça os
requisitos da aplicação
• Qualquer complexidade/generalidade desnecessária custa
mais esforço de desenvolvimento e verificação.
24/03/2018 Pós-graduação em Internet das Coisas 186
Arquitetura de Software Embarcado
• Quatro escolhas mais comuns:
• Round Robin simples
• Round Robin com interrupções
• Round Robin com interrupções e fila de funções
• Arquiteuras baseadas em sistemas operacionais de
tempo-real
• As arquiteturas estão ordenadas por ordem de crescente
complexidade
• A arquitetura Round Robin (RR) também é chamadas
execução cíclica na literatura sobre tempo-real
• A principal diferencial entre as abordagens baseadas em
RR e RTOS é que no RR o agendamento e o controle de
admissão é feito pelo desenvolvedor em vez de deixá-lo
para o SO
24/03/2018 Pós-graduação em Internet das Coisas 187
Round Robin
• É a arquitetura mais simples, um loop único verifica
dispositivos em sequência predefinida e executa a
operações de E/S imediatamente.
1 while(1) {
2 if (device_1_ready()){/*Executa E/S e computação do D1.*/}
3 if (device_2_ready()){/*Executa E/S e computação do D2.*/}
4 ...
5 if (device_N_ready()){/*Executa E/S e computação do DN.*/}
6 }
• Funciona bem para o sistema com poucos dispositivos,
restrições de tempo triviais e custos de processamento
proporcionalmente pequeno
• Tempo de resposta do dispositivo “i” é igual a WCET do
corpo do loop. (WCET - Worst Case Execution Time)
24/03/2018 Pós-graduação em Internet das Coisas 188
Exercício
5.2- Copie o projeto “serial” com o novo nome de “round_robin”
e crie um programa que utilize a arquitetura Round Robin para
executar as tarefas:
1 verificar chaves -> enviar “acionado” pela serial quando
ativadas
2 verificar serial -> ligar/desliga LED verde (comandos l e d)
3 quando disponível vbat e temp -> enviar seus valores pela
serial
24/03/2018 Pós-graduação em Internet das Coisas 189
Round Robin
• Round Robin periódico
• Caso o sistema necessite executar operações em
diferentes frequências
• Adicione um código para aguardaruma quantidade variável
de tempo
1 while(1) {
2 waitForNextPeriod(10); // idle for up to 10 ms
3 if (device_1_ready()) { /*Executa E/S e computação do D1.*/ }
4 ...
• Exercício:
• Pense em como implementar um loop que é executado a
cada 10 ms e como medir o desvio
24/03/2018 Pós-graduação em Internet das Coisas 190
Exercício
5.3- Copie o projeto “round_robin” com o novo nome de
“round_robin_p” e execute o laço principal a cada 0,5 segundos,
mantendo as restrições das tarefas e utilizando a arquitetura
Round Robin periódico. Adicione a tarefa:
4 a cada segundo -> enviar valor do ADC pela serial e trocar
o estado LED vermelho
24/03/2018 Pós-graduação em Internet das Coisas 191
Round Robin
• Limitações da arquitetura:
• Se alguns dispositivos exigem pequenos tempos de
resposta, enquanto outros têm WCET grande, não será
possível garantir que todas as restrições de tempo sejam
atendidas
• A arquitetura é frágil, adicionar uma nova tarefa pode
facilmente causar prazos perdidos
• Questão:
• A ordem dos dispositivos é significativa?
• Mesma pergunta, mas com código para dispositivos com
diferentes tempos de processamento e restrições de
tempo?
24/03/2018 Pós-graduação em Internet das Coisas 192
Round Robin com Interrupções
• Eventos de hardware que exigem pequenos tempos de
resposta manipulados por ISRs
• Normalmente, ISRs fazem pouco mais do que definir flags
e copiar dados
1 bool f_device_1 = FALSE;
2 bool f_device_2 = FALSE;
3 ...
4 void interrupt handle_dev_1() {
5 // handle device 1
6 f_device_1 = TRUE;
7 }
8 ...
9 void main() {
10 while (1) {
11 if(f_device_1) {
12 f_device_1 = FALSE;
13 // do processing related to device 1...}
14 if (f_device_2) {
15 ...}
16 }}
24/03/2018 Pós-graduação em Internet das Coisas 193
Exercício
5.4- Copie o projeto “round_robin_p” com o novo nome de
“round_robin_int” e utilize as interrupções da serial, ADC, timer
e pinos para implementar a arquitetura Round Robin com
interrupções.
1 Comente a função de sincronização do loop
2 Inclua os cabeçalhos.
3 Inclua as configurações.
4 Inclua as funções de tratamento das interrupções.
5 Edite as tarefas para funcionar com as interrupções.
24/03/2018 Pós-graduação em Internet das Coisas 194
Round Robin com Interrupções
• A latência de um ISR é função do tempo de resposta de
ISR de maior prioridade
• O limite inferior da latência do loop RR é o tempo de
resposta das ISRs
Todo código
Todas tarfefas
ISR Disp. 1
RR RR+I
Maior
Prioridade
Menor
Prioridade
ISR Disp. 2
ISR Disp. 3
24/03/2018 Pós-graduação em Internet das Coisas 195
Round Robin com Interrupções
• Desvantagens
• Todo o código de tarefa é executado na mesma prioridade
• Pode-se testar alguns flags várias vezes dentro do corpo
do loop para reduzir a latência
• Bugs de dados compartilhados
• Questão:
• E se um dos dispositivos requer grande quantidade de
tempo de processamento (maior do que a restrição de
tempo de outros?)
24/03/2018 Pós-graduação em Internet das Coisas 196
RR+I e Fila de Funções
• Em vez de ordem fixa, o programa gerencia a ordem de
execução
1 #define DEV_1 1
2 #define DEV_2 2
3 ...
4 void interrupt handle_DEV_1() {
5 // deal with device
6 enqueue(DEV_1);
7 }
8 ...
9 void main() {
10 while (1) {
11 switch (dequeue()) {
12 case DEV_1: // process DEV_1
13 break;
14 ...
15 default: // empty queue nothing to do
16 }
17 }
18 }
24/03/2018 Pós-graduação em Internet das Coisas 197
RR+I e Fila de Funções
• Pode-se usar ponteiros de função, mas eles adicionam
complexidade
• PF são úteis quando é desejado não fixar no loop principal
a chamada dos códigos de tratamento de cada dispositivos
• enqueue() reordena a fila para melhorar a latência de
dispositivos de alta prioridade
• Para funções de longa duração: divida-as em múltiplas
unidades menores
• Pergunta: isso melhora a latência?
• Questão
• Considere a implementação de dequeue(), que tipo de
estrutura de dados você usaria (por que), é necessário um
cuidado especial?
24/03/2018 Pós-graduação em Internet das Coisas 198
2◦ Trabalho
2◦ Trabalho
Copie o projeto “round_robin_int” com o novo nome de
“round_robin_ff” e implemente a arquitetura Round Robin com
interrupções e fila de funções. Utilize um escalonador fifo onde
só a tarefa das chaves tem prioridade sobre as outras.
1 utilize um enum para definir as tarefas:
enum {t_ch_direita = 1, t_ch_esquerda, t_serial, t_adc, t_timer};
2 Utilize as funções dequeue() e enqueue().
24/03/2018 Pós-graduação em Internet das Coisas 199
Sistema Operacional de Tempo Real
• Conta com operação de agendamento de tarefas
• Controle de escalonamento preemptivo para garantir que
os prazos sejam cumpridos
1 static pthread_t thread_1;
2 ...
3 void interrupt handle_DEV_1() {
4 // handle device
5 CHECK( pthread_wakeup(thread_1) );
6 }
7 ...
8 void task_1() {
9 while (1) {
10 pthread_suspend_np();
11 // process device 1 I/O
12 }
13 }
14 ...
24/03/2018 Pós-graduação em Internet das Coisas 200
Sistema Operacional de Tempo Real
• O escalonador em um RTOS cuida do agendamento de
todas as tarefas de acordo com sua prioridade
• As tarefas de longa duração, de baixa prioridade, podem
sofre preempção por tarefas de prioridades mais altas
Todo código
Todas tarfefas
ISR Disp. 1
RR RR+I
Maior
Prioridade
Menor
Prioridade
ISR Disp. 2
ISR Disp. 3
Tarfefa 1
ISR Disp. 1
RTOS
ISR Disp. 2
ISR Disp. 3
Tarfefa 2
24/03/2018 Pós-graduação em Internet das Coisas 201
Sistema Operacional de Tempo Real
• Serviços que um RTOS pode oferecer:
• agendamento de tarefas
• criar/terminar threads
• operações de temporização de threads
• preempção
• Sincronização
• semaforos e mutexes
• Entrada/Saída
• gerenciamento de interrupções
• gerenciamento de memória
• pilhas separadas
• segmentação
• alocação/desalocação
• Sistema de arquivos
• armazenamento persistente
• Segurança
• user vs. kernel space
• gerenciamento de identidade
24/03/2018 Pós-graduação em Internet das Coisas 202
Conclusão
• Arquiteturas de software descrevem a estrutura de um
sistema independentemente da sua função
• Round Robin é uma arquitetura simples para dispositivos
com poucas (ou uniformes) restrições de temporização
• Round Robin com Interrupções estende o RR com a
utilização de interrupção de baixa latência
• Round Robin com interrupções e filas de funções permite o
agendamento dinâmico de tarefas sob controle
programático
• Os sistemas operacionais em tempo real aliviam os
programadores de ter que lidar com agendamento e
gerenciamento de tempo
24/03/2018 Pós-graduação em Internet das Coisas 203
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
I Instalação do Contiki-OS
I Criando um Projeto do
Contiki-OS no CCS
I Entendendo o Programa
I Copiando um Projeto Contiki
no CCS
I Entrada e Saída Serial
I Acionamento de LEDs com o
Event Timer
I Eventos das Chaves
I Conversor ADC
I Acionamento PWM
I Monitor de Tensão de Bateria
e Temperatura
I 3◦ Trabalho - Protocolo
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
07/04/2018 Pós-graduação em Internet das Coisas 204
SEXTA AULA
Instalação do Contiki-OS. Criação de projetos utilizando o
Contiki no CCS. Entrada e Saída Serial, acionamento de LEDs,
leitura de chaves, conversor ADC, acionamento PWM e Monitor
de Tensão de Bateria e Temperatura. 3◦ Trabalho.
07/04/2018 Pós-graduação em Internet das Coisas 205
Instalação do Contiki-OS
http://www.contiki-os.org/
Instalação do Contiki-OS
cd ~/workspace_v7git clone https://github.com/contiki-os/contiki.git
cd contiki
git submodule update --init
sudo apt-get install gcc-arm-none-eabi srecord \
util-linux cutecom
07/04/2018 Pós-graduação em Internet das Coisas 206
Criando um Novo Projeto do
Contiki-OS no CCS
07/04/2018 Pós-graduação em Internet das Coisas 207
Configuração do Projeto do Contiki-OS
• Target: SimpleLink Wireless MCU CC2650F128
• Project Name: ctk_hello_world
• Compiler Version: GNU
• Output File: Executable
• Project template: Empty project
07/04/2018 Pós-graduação em Internet das Coisas 208
Adicionando uma Pasta ao Projeto
07/04/2018 Pós-graduação em Internet das Coisas 209
Configurando o Nome da Pasta
Nome da pasta: Source
07/04/2018 Pós-graduação em Internet das Coisas 210
Adicionando Arquivos
07/04/2018 Pós-graduação em Internet das Coisas 211
Selecionando os Arquivo de
Configuração
Baixe o arquivo ctk_hello_world.zip e descompacte.
Adicione os arquivos ao projeto:
• makefile.targets - makefile para “enganar” o CCS
• Source/Makefile - Makefile do contiki
• Source/Makefile.target - Configurações da placa utilizada
• Source/ctk_hello_world.c - Exemplo inicial do Contiki
07/04/2018 Pós-graduação em Internet das Coisas 212
Configurando as Propriedades
07/04/2018 Pós-graduação em Internet das Coisas 213
Alterando as Opções Build->Behavior
Acesse a janela Build->Behavior e modifique as opções para:
contiki, contiki e contiki_clean.
07/04/2018 Pós-graduação em Internet das Coisas 214
Arquivo: makefile.targets
O makefile.targets serve para “enganar” o CCS. Esse arquivo
não precisa ser editado. Ele é chamado pelo CCS e
simplesmente chama o Source/Makefile e copia o arquivo .elf
gerado para pasta correta.
• É necessário que o projeto e o arquivo principal.c tenham o
mesmo nome!
• Por ser tratar de um projeto do Contiki, as configurações do
projeto no CCS não afetam a compilação!
1 contiki:
2 cd ../Source && $(MAKE)
3 cd ../Source && rename.ul .elf .out *.elf
4 mv ../Source/*.out .
5
6 contiki_clean:
7 cd ../Source && $(MAKE) clean
8 cd .. && rm -rf Debug/
07/04/2018 Pós-graduação em Internet das Coisas 215
Arquivo: Source/Makefile
O Makefile do Contiki deve ter o nome do projeto igual ao
arquivo principal.c, as configurações específicas do projeto e o
caminho para o Contiki.
1 CONTIKI_PROJECT = ctk_hello_world
2 all: $(CONTIKI_PROJECT)
3
4 CFLAGS += -g
5
6 CONTIKI = ../../contiki
7 include $(CONTIKI)/Makefile.include
07/04/2018 Pós-graduação em Internet das Coisas 216
Arquivo: Source/Makefile.target
O arquivo Makefile.target guarda as configurações da
plataforma utilizada pelo Contiki. Para uso com o launchpad
não precisa ser editado.
1 TARGET = srf06-cc26xx
2 BOARD = launchpad/cc2650
07/04/2018 Pós-graduação em Internet das Coisas 217
Arquivo: Source/ctk_hello_world.c
Exemplo inicial do Contiki
1 #include "contiki.h"
2 #include <stdio.h> /* For printf() */
3 /*------------------------------------------------*/
4 PROCESS(hello_world_process, "Hello world process");
5 AUTOSTART_PROCESSES(&hello_world_process);
6 /*------------------------------------------------*/
7 PROCESS_THREAD(hello_world_process, ev, data)
8 {
9 PROCESS_BEGIN();
10
11 printf("Hello, world\n");
12
13 PROCESS_END();
14 }
15 /*------------------------------------------------*/
07/04/2018 Pós-graduação em Internet das Coisas 218
Exercício
6.1- Compile e grave no launchpad o programa ctk_hello_world.
Abra o terminal serial cutecom e verifique a saída do programa.
07/04/2018 Pós-graduação em Internet das Coisas 219
Copiando um Projeto Contiki no CCS
Etapas para copiar e configurar o projeto:
1 Copie o projeto “ctk_hello_world” como “ctk...”
2 Renomeie o arquivo “ctk_hello_world.c” como “ctk....c”
3 Edite o Source/Makefile e modifique a variável:
CONTIKI_PROJECT = ctk...
4 Opcional: Renomeie o processo no arquivo “ctk....c”
07/04/2018 Pós-graduação em Internet das Coisas 220
Entrada e Saída Serial
Cabeçalho:
1 #include "dev/serial-line.h"
2 #include "dev/cc26xx-uart.h"
3 #include <stdio.h> /* For printf() */
Código:
1 PROCESS_BEGIN();
2 cc26xx_uart_set_input(serial_line_input_byte);
3 printf("Start serial!\n");
4 while(1) {
5 PROCESS_YIELD();
6 if(ev == serial_line_event_message) {
7 printf("received line: %s\n", (char *)data);
8 }
9 }
10 PROCESS_END();
07/04/2018 Pós-graduação em Internet das Coisas 221
Exercício
6.2- Copie o projeto ctk_hello_world como ctk_serial e
modifique o código para que o envio das strings “liga” e
“desliga” retornem as strings “ligado Ok” e “desligado Ok”
respectivamente. Qualquer string diferente dessas enviada deve
ser respondida com a string “comando inválido”.
07/04/2018 Pós-graduação em Internet das Coisas 222
Acionamento de LEDs com o
Event Timer
Cabeçalho:
1 #include "sys/etimer.h"
2 #include "dev/leds.h"
Código:
1 static struct etimer timer;
2 while(1)
3 {
4 etimer_set(&timer, CLOCK_CONF_SECOND);
5 PROCESS_WAIT_EVENT_UNTIL(ev==PROCESS_EVENT_TIMER);
6 leds_toggle(LEDS_RED);
7 }
07/04/2018 Pós-graduação em Internet das Coisas 223
Exercício
6.3- Copie o projeto ctk_hello_world como ctk_simples e
adicone o código para o LED vermelho ser acionado por um
etimer a cada um segundo.
6.4- Crie outro processo com o LED verde piscando a cada 2
segundos.
07/04/2018 Pós-graduação em Internet das Coisas 224
Eventos das Chaves
Cabeçalho:
1 #include "button-sensor.h"
Código:
1 while (1)
2 {
3 PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event);
4 if (data == &button_left_sensor)
5 {
6 printf("Left: Pin %d, press duration %d clock ticks\n",
7 (&button_left_sensor)->value(BUTTON_SENSOR_VALUE_STATE),
8 (&button_left_sensor)->value(BUTTON_SENSOR_VALUE_DURATION));
9 if ((&button_left_sensor)->value(BUTTON_SENSOR_VALUE_DURATION)
10 > CLOCK_SECOND)
11 {
12 printf("Long button press!\n");
13 }
14 }
15 }
07/04/2018 Pós-graduação em Internet das Coisas 225
Exercício
6.5- Copie o projeto ctk_hello_world como ctk_botoes e altere o
código para trocar o estado do LED vermelho a cada vez que a
chave ficar mais de 2 segundos pressionada. Utilize o cutecom
para ver as informações do acionamento.
07/04/2018 Pós-graduação em Internet das Coisas 226
Conversor ADC
Cabeçalho:
1 #include "aux-ctrl.h"
2 #include "ti-lib.h"
3 static aux_consumer_module_t adc_aux = {.clocks = AUX_WUC_ADI_CLOCK |
4 AUX_WUC_ANAIF_CLOCK | AUX_WUC_SMPH_CLOCK};
Código:
1 static int val,adj_val,adj_mv;
2 /* Request AUX access, with ADI and SMPH clocks */
3 aux_ctrl_register_consumer(&adc_aux);
4 // Connect AUX IO7 (DIO23) as analog input.
5 ti_lib_aux_adc_select_input(ADC_COMPB_IN_AUXIO7);
6 ti_lib_aux_adc_enable_sync(AUXADC_REF_FIXED,AUXADC_SAMPLE_TIME_2P7_US,
7 AUXADC_TRIGGER_MANUAL);
8 ti_lib_aux_adc_gen_manual_trigger();
9 val = ti_lib_aux_adc_read_fifo();
10 adj_val = ti_lib_aux_adc_adjust_value_for_gain_and_offset(
11 val,
12 ti_lib_aux_adc_get_adjustment_gain(AUXADC_REF_FIXED),
13 ti_lib_aux_adc_get_adjustment_offset(AUXADC_REF_FIXED));
07/04/2018 Pós-graduação em Internet das Coisas 227
Conversor ADC
Continuação código:
14 adj_mv = ti_lib_aux_adc_value_to_microvolts(
15 AUXADC_FIXED_REF_VOLTAGE_NORMAL, adj_val);
16 ti_lib_aux_adc_disable();
17 aux_ctrl_unregister_consumer(&adc_aux);
18 printf("ADC=%i\n",adj_mv);
07/04/2018 Pós-graduação em Internet das Coisas 228
Exercício
6.6- Copie o projeto ctk_hello_world como ctk_adc e altere o
código para que faça uma medição do ADC a cada segundo
usando um etimer.
07/04/2018 Pós-graduação em Internet das Coisas 229
Acionamento PWM
Cabeçalho:
1 #include "ti-lib.h"
2 #include "lpm.h"
3 LPM_MODULE(pwm_module, NULL, NULL, NULL, LPM_DOMAIN_PERIPH);
Configuração:
1 static uint32_tload, duty=0;
2 static uint32_t freq=10000;
3 // Enable GPT0 clocks under active, sleep, deep sleep
4 ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_TIMER0);
5 ti_lib_prcm_peripheral_sleep_enable(PRCM_PERIPH_TIMER0);
6 ti_lib_prcm_peripheral_deep_sleep_enable(PRCM_PERIPH_TIMER0);
7 ti_lib_prcm_load_set();
8 while(!ti_lib_prcm_load_get());
9 // Drive the I/O ID with GPT0 / Timer A
10 ti_lib_ioc_port_configure_set(BOARD_IOID_LED_1, IOC_PORT_MCU_PORT_EVENT0,
11 IOC_STD_OUTPUT);
12 // GPT0 / Timer A: PWM, Interrupt Enable
13 HWREG(GPT0_BASE + GPT_O_TAMR) = (TIMER_CFG_A_PWM&0xFF)|GPT_TAMR_TAPWMIE;
07/04/2018 Pós-graduação em Internet das Coisas 230
Acionamento PWM
Continuação da configuração:
14 // Register ourself with LPM. This will keep the PERIPH PD
15 // powered on during deep sleep, allowing the buzzer to keep
16 //working while the chip is being power-cycled
17 lpm_register_module(&pwm_module);
18 // Stop the timer
19 ti_lib_timer_disable(GPT0_BASE, TIMER_A);
20 load = (GET_MCU_CLOCK / freq);
21 ti_lib_timer_load_set(GPT0_BASE, TIMER_A, load);
22 ti_lib_timer_match_set(GPT0_BASE, TIMER_A, 0);
23 /* Start */
24 ti_lib_timer_enable(GPT0_BASE, TIMER_A);
Código:
25 duty=load/2;
26 ti_lib_timer_match_set(GPT0_BASE, TIMER_A, load-duty);
07/04/2018 Pós-graduação em Internet das Coisas 231
Exercício
6.7- Copie o projeto ctk_hello_world como ctk_pwm e altere o
código para que o PWM faça o LED vermelho variar o brilho de
mínimo a máximo continuamente. Utilize um etimer para
temporizar o incremento.
07/04/2018 Pós-graduação em Internet das Coisas 232
Monitor de Tensão de Bateria e
Temperatura
Cabeçalho:
1 #include "lib/sensors.h"
2 #include "batmon-sensor.h"
Código:
1 SENSORS_ACTIVATE(batmon_sensor);
2 int value;
3 value = batmon_sensor.value(BATMON_SENSOR_TYPE_TEMP);
4 if(value != CC26XX_SENSOR_READING_ERROR) {
5 printf("Tem=%i\n",value);
6 }
7 value = batmon_sensor.value(BATMON_SENSOR_TYPE_VOLT);
8 if(value != CC26XX_SENSOR_READING_ERROR) {
9 printf("Bat=%i\n",(value * 125) >> 5);
10 }
07/04/2018 Pós-graduação em Internet das Coisas 233
Exercício
6.8- Copie o projeto ctk_hello_world como ctk_batmon e altere
o código para que faça a medição dos valores de tensão da
bateria e temperatura a cada segundo utilizando um etimer.
07/04/2018 Pós-graduação em Internet das Coisas 234
3◦ Trabalho
Implemente o suporte ao protocolo descrito no arquivo serial.c sem
modifica-lo no CC2650 utilizando o Contiki. Implemente o códigos das
seguintes funções:
void Serial_print (const char *str)
void Serial_println(const char *str)
int digitalRead(char pin)
void digitalWrite(char pin, char value)
void analogWrite(char pin,unsigned char value)
int analogRead(char pin)
Arquivo com as definições das funções: funcoes.c
Os pinos que devem ser utilizados no trabalho são:
• 7 - Saida Digital - LED verde
• 13 - Entrada Digital - Chave esquerda
• 6 - Saida Analógica - LED vermelho
• 23 - Entrada Analógica - ADC
07/04/2018 Pós-graduação em Internet das Coisas 235
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
I Redes com o Contiki
I Socket UDP
I Socket TCP
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
14/04/2018 Pós-graduação em Internet das Coisas 236
SÉTIMA AULA
tópicos
14/04/2018 Pós-graduação em Internet das Coisas 237
Redes com o Contiki
14/04/2018 Pós-graduação em Internet das Coisas 238
Socket UDP
Cabeçalho:
1
Código:
1
14/04/2018 Pós-graduação em Internet das Coisas 239
Exercício
7.1- Copie o projeto ctk_hello_world como ctk_botoes e altere o
código para
14/04/2018 Pós-graduação em Internet das Coisas 240
Socket TCP
Cabeçalho:
1
Código:
1
14/04/2018 Pós-graduação em Internet das Coisas 241
Exercício
7.2- Copie o projeto ctk_hello_world como ctk_botoes e altere o
código para
14/04/2018 Pós-graduação em Internet das Coisas 242
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
28/04/2018 Pós-graduação em Internet das Coisas 243
OITAVA AULA
tópicos
28/04/2018 Pós-graduação em Internet das Coisas 244
Conteúdo
1 Primeira Aula - 24/02/2018
2 Segunda Aula - 03/03/2018
3 Terceira Aula - 10/03/2018
4 Quarta Aula - 17/03/2018
5 Quinta Aula - 24/03/2018
6 Sexta Aula - 07/04/2018
7 Sétima Aula - 14/04/2018
8 Oitava Aula - 28/04/2018
9 Nona Aula - 28/04/2018
I Finalização e apresentação
do trabalho final
28/04/2018 Pós-graduação em Internet das Coisas 245
NONA AULA
Finalização e apresentação do trabalho final
28/04/2018 Pós-graduação em Internet das Coisas 246
	Primeira Aula - 24/02/2018
	Introdução ao KICAD
	Utilização do KICAD
	Esquemático e PCB
	Captura de Esquemático
	Associação de Footprints
	Criação da PCB
	Segunda Aula - 03/03/2018
	Plataforma LAUNCHXL-CC2650
	IDE Code Composer Studio - CCS
	Compilando a Biblioteca CC26xxware
	Compilando um Projeto Simples
	Entendendo o Programa
	Depuração do Projeto
	Terceira Aula - 10/03/2018
	ADC
	PWM
	Serial
	1 Trabalho
	Quarta Aula - 17/03/2018
	Monitor de Bateria e Temperatura
	Interrupção do Timer
	Interrupção do System Tick
	Interrupção dos Pinos
	Interrupção da Serial
	Quinta Aula - 24/03/2018
	Interrupção do ADC
	Arquitetura de Software Embarcado
	Round Robin
	Round Robin com Interrupções
	Round Robin com Interrupções e Fila de Funções
	2 Trabalho
	Sistema Operacional de Tempo Real
	Conclusão
	Sexta Aula - 07/04/2018
	Instalação do Contiki-OS
	Criando um Projeto do Contiki-OS no CCS
	Entendendo o Programa
	Copiando um Projeto Contiki no CCS
	Entrada e Saída Serial
	Acionamento de LEDs com o Event Timer
	Eventos das Chaves
	Conversor ADC
	Acionamento PWM
	Monitor de Tensão de Bateria e Temperatura
	3 Trabalho - Protocolo
	Sétima Aula - 14/04/2018
	Redes com o Contiki
	Socket UDP
	Socket TCP
	Oitava Aula - 28/04/2018
	Nona Aula - 28/04/2018
	Finalização e apresentação do trabalho final