1

KIT didático com a placa DK101

Sumário

1. Introdução ..................................................................................... 2

2. Plataforma Arduino ....................................................................... 3

3. Plataforma Radiuino ...................................................................... 5

4. Princípio de funcionamento do Kit didático ................................... 7

4.1. Sensor de Temperatura........................................................................8

4.2. Sensor de Luminosidade LDR...............................................................8

4.3. Relé eletromecânico............................................................................9

4.4. Componentes do Kit DK101..................................................................9

4.5. Possíveis aplicações ............................................................................9

5. Tutorial do Kit ..............................................................................11

5.1. Configuração da placa do Radiuino no IDE........................................ 11

5.2. Ajuste na Comunicação Serial............................................................12

5.3. Ajustes no Firmeware da base............................................................13

5.4. Ajustes do Firmeware no nó sensor....................................................17

6. Softwares de aplicação ................................................................ 20

6.1. Software RadiuinoTest.......................................................................20

6.2. Software de controle em PYTHON.................................................... 21

7. Exemplo de aplicação..................................................................24

8. Considerações finais e Conclusão.................................................26

2

1. Introdução

O Kit didático apresentado neste documento, baseado na placa de aplicação

DK101, foi desenvolvido para aprimorar o conhecimento técnico de maneira fácil e

didática. Com ele, é possível realizar medições de algumas grandezas físicas, tais

como temperatura e umidade. Além disso, é possível fazer o acionamento de

dispositivos como lâmpadas, ventiladores, etc. Entretanto, é necessário que haja um

conhecimento básico de redes de sensores sem fio e de algumas plataformas de

desenvolvimento tais como Arduino e Radiuino. Tal conhecimento é essencial para

a utilização do Kit. Por isso, esse documento objetiva fornecer suporte técnico aos

que se interessam pela área de redes de sensores sem fio e pretendem utilizar o Kit

com a placa DK101 para aplicações variadas. Este documento foi organizado da

seguinte maneira: a Seção 2 apresenta a plataforma Arduino; A Seção 3 se trata da

plataforma Radiuino; a Seção 4 mostra o princípio de funcionamento do Kit DK101.

A seção 5 apresenta um tutorial a respeito do Kit DK101; a Seção 6 diz respeito aos

softwares utilizados para rodar as aplicações do Kit; a Seção 7 mostra um exemplo

de aplicação e; a Seção 8 aborda a conclusão.

3

2. Plataforma Arduino

A plataforma Arduino é voltada para projetos de automação residencial. Existe

uma grande variedade de sensores que podem ser utilizados no Arduino tais como

de temperatura, umidade, distância, luminosidade, som, etc. Tal plataforma é

considerada a chave para o entendimento da plataforma Radiuino que, por sua vez,

é a base do Kit didátoico. O Arduino pode ser entendido, basicamente, por um

ambiente de desenvolvimento integrado de software (Integrated Development

Environment, IDE) e um Hardware. A conexão entre Hardware/Software é feita por

um cabo Serial de barramento universal (Universal Serial Bus, USB). O que permite

tal conexão é um pequeno programa denominado Bootloader. A Figura 1 apresenta

o esquema de funcionamento da plataforma Arduino. As rotinas e programas,

desenvolvidos na IDE, são chamados de Firmwares. Estes são instalados no

microcontrolador presente no Hardware (que pode ser o circuito integrado

Atmega328) através do cabo USB. Dessa forma, pode-se controlar dispositivos e

fazer a utilização dos sensores. Esse é o princípio básico de automação e controle de

processos. O microcontrolador é o “cérebro” de qualquer projeto automatizado, já

que é responsável pela tomada das decisões na automação dos processos. O

esquema de ligação do microcontrolador Atmega 328 pode ser encontrado na seção

Anexo 1 desse documento. A Figura 2 ilustra o ambiente de desenvolvimento do

Arduino, no qual são desenvolvidos os Firmewares. Algumas informações relevantes

como compilação, Upload e desenvolvimento do Firmeware foram destacadas na

fig.2.

Fig.1. Plataforma Arduino.

4

Fig.2. Ambiente de desenvolvimento do Arduino.

5

3. Plataforma Radiuino

A plataforma Radiuino, representada pela Figura 3, é a base do Kit Didático. Pode

ser entendida da mesma forma que a plataforma Arduino (fig 1), já que se trata da

integração de um IDE e um Hardware. O Hardware da plataforma Radiuino consiste

na associação de um microcontrolador (que pode ser o ATmega328 ou ATmega168,

por exemplo) e um transceptor capaz de realizar transmissões e recepções via

radiofrequência. O transceptor utilizado nessa plataforma é o CC1101. De certa

forma, pode-se dizer que a plataforma Radiuino é uma união do Arduino com a

comunicação por rádiofrequência. Essa união permite que dispositivos sejam

controlados e supervisionados à distância. O meio de transmissão utilizado por

ondas de rádio é o ar. A Figura 4 ilustra o dispositivo BE900, composto por um

microcontrolador ATmega328 e um transceptor de rádio CC1101.

A equivalência de pinagem entre o BE900 e o Arduino foi disponibilizada na

Seção Anexos 1. O BE900 apresenta conversores analógico-digitais (AD), entradas e

saídas (I/O) e capacidade de transmissão e recepção de sinais de rádio. Todas as

informações são processadas no microcontrolador, recebidas ou transmitidas pelo

transceptor rádio e entregues ao computador por meio de um cabo USB. Existe,

ainda, a necessidade da inserção de um conversor USB-Serial entre o BE900 e o

computador, tal como ilustrado na fig.4. De maneira resumida, o BE900 é o

Hardware principal do Kit DK101.

Fig.3. Plataforma Radiuino.

6

Fig.4. BE900 e comunicação com o computador.

7

4. Princípio de funcionamento do Kit didático

O princípio de funcionamento do Kit é bastante simples: dois rádios BE900 foram

implementados, um funcionando como base de dados e o outro como nó sensor. A

comunicação entre eles é feita por radiofrequência. A base conta com um BE900 e

um conversor USB Serial. Tal conversor é necessário porque o BE900 em si não é

capaz de se comunicar com o computador. Já o nó sensor apresenta componentes

como sensores de temperatura e umidade, Leds, um relé eletromecânico e, por fim,

outro BE900.

Os Datasheets e outras informações a respeito dos sensores serão apresentadas

posteriormente. A respeito do funcionamento do Kit, a base requisita os controles.

Essas requisições são transmitidas via radiofrequência ao BE900 do nó sensor que,

por sua vez, toma as devidas decisões e retransmite os novos estados para a base.

Por exemplo, a base “deseja” coletar informações a respeito da temperatura de

algum ambiente. As requisições são enviadas ao nó sensor. Este recebe a

informação, calcula a temperatura do ambiente, retransmite à base e, então, a

temperatura é disponibilizada no computador. A mesma ideia pode ser aplicada ao

relé eletromecânico e ao sensor de luminosidade. A Figura 5 ilustra o Kit com o

DK101 (Placa de aplicação situada no nó sensor).

Fig.5. Kit DK101.

Placa de aplicação

Programador BE900

Antenas

Cabo USB

Fonte de

alimentação 12V

8

4.1. Sensor de Temperatura

O sensor de temperatura presente no Kit é o MCP9700 e foi fabricado

pela empresa Microchip. A leitura da temperatura, no caso da placa DK101,

se resume à utilização da entrada ADC0 do dispositivo BE900. Deve-se fazer

uma leitura analógica, cuja tensão varia de 0 a 3,3V (faixa de alimentação do

BE900). Como o conversor AD do ATmega 328 é de 10 bits, os valores de

tensão serão representados na faixa de 0 a 1023 ( 1024210 ). Essas

informações já estão no Firmeware, que será apresentado posteriormente.

Entretanto, deve-se utilizar a equação (1) para que o valor lido na entrada AD

seja convertido para temperatura:

50100)1023

3,3( ADVaTemperatur (1)

em que ADV representa o valor de 0 a 1023. Outras informações a respeito

desse sensor foram disponibilizadas na Seção Anexo 2.

4.2. Sensor de Luminosidade LDR

O sensor de luminosidade utilizado no Kit, conhecido como Resistor

Dependente de Luz (Light Dependent Resistor, LDR), é simplesmente um

resistor, cuja resistência varia de acordo com a iluminação do ambiente. Se

a luminosidade estiver baixa, sua resistência pode chegar até alguns MΩ.

Caso contrário, a resistência é bastante pequena. Desse modo, pode-se

realizar uma leitura analógica da tensão no LDR. Tal leitura é feita no ADC1

do BE900 e o resultado será um valor de 0 a 1023. Outras informações a

respeito do LDR podem ser encontradas na Seção Anexo 2.

Além disso, é importante ressaltar que o LDR foi ligado na placa de

aplicação através de um divisor resistivo. Este, por sua vez, é alimentado pela

saída digital 5, tal como ilustrado na tabela de mapeamento dos pacotes da

placa DK101 (Tabela 1, Anexo 3). Esse tipo de ligação foi feita com o objetivo

de economizar energia nos momentos em que o sensor não estiver medindo

a luminosidade do ambiente. A saída digital 5 pode ser energizada via

software de acordo com o seguinte comando: DigitalWrite(5,HIGH). Outra

possível ativação do LDR é feita pelo Software RadiuinoTest, que será

apresentado posteriormente.

9

4.3. Relé eletromecânico

O relé utilizado na placa de aplicação DK101 do Kit possui os dois contatos da

bobina e outros três contatos: comum, normalmente fechado (NF) e

normalmente aberto (NA). A passagem de corrente pela bobina do relé faz

com que o terminal comum feche o contato com o NA. Logo, é possível

realizar o acionamento de dispositivos como lâmpadas, ventiladores, entre

outros. No Software RadiuinoTest, o acionamento do relé é feito no byte 43,

alterando seu valor de 0 para 1. Maiores informações a respeito do relé estão

disponíveis na Seção Anexo 2. Posteriormente, foi apresentado um exemplo

de projeto que envolve o relé e o sensor de luminosidade.

4.4. Componentes do Kit com o DK101

Componentes da base

Um dispositivo BE900 (controlador ATMEGA 328P e transceptor rádio CC1101);

Um conversor USB-Serial programador UartSbee;

Um cabo USB;

Uma antena;

Componentes do nó sensor

Um dispositivo BE900 (controlador ATMEGA 328P e transceptor rádio CC1101);

Placa de aplicação DK101 (sensores de temperatura e de luminosidade, Leds e

relé eletromecânico);

Uma antena;

Uma fonte de alimentação 12V;

Um suporte para pilhas;

4.5. Possíveis aplicações

A primeira delas conta com a seguinte situação: imagine que você precise manter

uma alta luminosidade num determinado ambiente e sua localização é distante.

Então, basta instalar o nó sensor nesse ambiente e coletar as medições a respeito

da luminosidade. Se a luminosidade estiver muito baixa, é feito o acionamento

automático da iluminação. Isso pode executado facilmente acoplando a

iluminação ao relé eletromecânico (presente na placa de aplicação do Kit). A

comunicação entre base/nó sensor é estabelecida via radiofrequência e, então,

por ser aplicada para longas distâncias (aproximadamente 1 Km).

Outra aplicação seria com a utilização do sensor de temperatura. A temperatura

de algum ambiente poderia ser monitorada e, dependendo do valor, poderiam

10

ser acionados aquecedores ou ventiladores. Da mesma forma que a aplicação

citada acima, isto também poderia ser implementado para longas distâncias

(aproximadamente 1 Km).

Monitoramento de luminosidade e temperatura numa estufa localizada à

distância da base de dados. Recentemente, esse trabalho foi realizado na Feagri

(Faculdade de engenharia Agrícola) da Unicamp.

11

5. Tutorial do Kit

Este tópico tem por objetivo ensinar o conteúdo básico necessário para a

utilização do Kit didático. Foram apresentados os ajustes básicos na programação

das unidades da base e do nó sensor, uma vez que cada BE900 possui características

específicas. Nesse documento será utilizada a IDE do Arduino, encontrada no site do

Radiuino (www.radiuino.cc). O link para download da IDE é o seguinte:

https://sourceforge.net/projects/radiuino/files/IDE%20Arduino%20-

%20Radiuino%20Ready/. O arquivo deve ser salvo em C:\Program Files (x86).

Algumas especificações aqui apresentadas devem ser feitas tanto para a base

quanto para o nó sensor. Isso será mostrado em detalhes nos tópicos 5.1, 5.2, 5.3 e

5,4.

5.1. Configuração da placa do Radiuino no IDE

Existem vários dispositivos de Hardware disponíveis no IDE do Arduino. O

dispositivo (ou placa) utilizado pela plataforma Radiuino é o BE900. Este pode

ser selecionado no IDE, em Tools/Board/BE900 (3,3V, 8 MHz) w/ATmega328. A

Figura 6 ilustra essa configuração.

Fig.6. Configuração da placa Radiuino no IDE.

12

5.2. Ajuste da Comunicação Serial

O conversor programador USB-Serial UartSbee é utilizado para programar

tanto a base quanto o nó sensor. Para isso, é necessário acessar Tools/Serial

Port/ COM#, em que # representa o número da porta Serial. Quando o conversor

USB-Serial é conectado pela primeira ao computador, é criada, imediatamente,

uma porta Serial exclusiva para o conversor em questão. No exemplo ilustrado

pela Figura 7, a porta Serial criada foi a COM4.

Fig.7. Ajuste da porta Serial.

13

5.3. Ajustes no Firmeware da base

Os Firmewares da base e do nó sensor podem ser encontrados segundo as

informações destacadas na Figura 8. A Figura 9 ilustra o Firmeware da base e é

possível observar as abas Radiuino_base, Headers.h, 1_Phy,_2_MAC e _3_NET. Na

camada física (_1_Phy) é necessária a realização de alguns ajustes nas variáveis

ilustradas pela Figura 10.

Fig.8. Localização dos Firmewares da base e do nó sensor.

14

Fig.9. Código fonte de programação da base.

15

Fig.10. Ajuste de variáveis da física.

A variável “power” está relacionada com a intensidade da potência de

transmissão e deve ser ajustada de acordo com a distância entre base e nó sensor. Como

ilustrado pela fig.10, existem 8 valores possíveis. Por convenção, utilizou-se “power = 7”,

já que se trata da maior potência (10dBm). A variável “channel” diz respeito ao canal de

transmissão. São 65 possibilidades no total, sendo que base e nó sensor devem estar

sintonizados no mesmo canal. Esses canais operam na faixa de 915MHz a 928MHz, com

um espaçamento espectral de 200KHz entre eles. No exemplo da figura 10, o canal 0 foi

utilizado (channel = 0). A variável “freq_offset” representa o ajuste de OFFSET, em

frequência, de cada rádio BE900 (base e nó sensor). Isso é necessário porque os

dispositivos BE900 contam com a presença de um cristal oscilador e capacitores

cerâmicos. Esses componentes provocam, de certa forma, um desvio em frequência que

precisa ser corrigido para garantir o bom funcionamento do sistema. Os OFFSETS são

medidos com equipamentos chamados de analisadores de espectro e já são

Potência de transmissão

Canal de comunicação

Offset de frequência

Velocidade da comunicação Serial

16

identificados em cada dispositivo BE900. A Figura 11 ilustra um BE900 etiquetado com

seu respectivo OFFSET em frequência, que deve ser igual ao valor da variável

“freq_offset”. Então, nesse exemplo utilizou-se freq_offset = 0xFB. E por fim, a taxa de

velocidade da comunicação Serial é dada pela variável “serial_baudrate”. É importante

ressaltar que as taxas da base e do nó sensor devem ser, essencialmente, iguais. No

exemplo da Fig.10, utilizou-se “serial_baudrate = 9600”.

Fig.11. OFFSET em frequência do BE900.

Na camada de rede (_3_Net), o único ajuste a ser feito é na variável “my_addr”,

cuja função é de representar o endereço de rede da base. Tal variável deve ser igual a 0,

ou seja, “my_addr = 0”.

Depois realizar todos esses ajustes, deve ser feito o encaixe do BE900 no

conversor programador USB-Serial e o Upload do código. A partir desse momento, um

dos rádios irá funcionar como base e ficará conectado ao computador por meio do

conversor USB-Serial. A Figura 12 ilustra a maneira como o rádio BE900 deverá ser ligado

ao conversor programador USB-Serial. É essencial deixar a saída da antena (destacada

na fig.12) logo acima da conexão do cabo USB.

OFFSET

17

Fig.12. Encaixe do BE900 no conversor programador USB-Serial.

5.4. Ajustes no Firmware do nó sensor

Os ajustes na programação do Firmeware do nó sensor são semelhantes aos

da base. O Firmeware pode ser acessado de acordo com as informações

destacadas na fig.8. A Figura 13 ilustra o código do nó sensor, que possui todas

as camadas da base acrescidas das camadas de transporte (_4_Transp) e de

aplicação (_5_App). A camada física deve ser ajustada da seguinte maneira: as

variáveis “power”, “channel” e “serial_baudrate” devem carregar os mesmos

valores inseridos na programação da base. Já a variável “freq_offset” varia de

acordo com as características físicas do BE900. Logo, deve-se seguir o valor de

referência tais como ilustram as fig.10 e fig.11. É importante lembrar que as

fig.10 e fig.11 ilustram apenas um exemplo de OFFSET e o valor correto a ser

inserido estará identificado em cada dispositivo BE900.

Já na camada de rede (_3_Net), a variável “my_addr” deve ser igual a um.

Então, a programação deve constar “my_addr = 1”. Na verdade, esses valores da

camada de rede definiram o endereço dessa forma: o endereço da base é zero e

o do sensor, um. Para criar uma rede com a base e vários nó sensores, cada

sensor deve possuir um “my_addr” diferente, referente a sua identificação na

rede. Pode-se fazer uma analogia às redes de computadores, nas quais cada

computador apresenta um IP diferente.

Feito isso, o conversor USB-Serial deve ser encaixado no nó sensor para que

seja feito o Upload do código. A Figura 14 mostra como deve ser feito o encaixe

Conexão da antena

Conector USB

18

do conversor USB-Serial na placa de aplicação. A seguir, serão apresentados os

softwares necessários para rodar as aplicações da plataforma Radiuino.

Fig.13. Código fonte de programação da base.

19

Fig.14. Encaixe do conversor USB-Serial na placa de aplicação.

20

6. Softwares de Aplicação

Nessa seção foram apresentados os Softwares de aplicação da plataforma

Radiuino: RadiuinoTest e PYTHON.

6.1. Software RadiuinoTest

A Figura 15 ilustra o RadiuinoTest. Este pode ser baixado no site do Radiuino

(www.radiuino.cc), através do link abaixo:

http://radiuino.cc/?page_id=28

A utilização do software RadiuinoTest é muito simples. É necessário inserir a

porta Serial, velocidade de transmissão, alterar o estado do Byte 8 de 0 para 1 e,

então, clicar no botão “Conectar”. O Byte 8 é o ID do nó sensor e o Byte 10, da base.

Esses valores foram ajustados na camada rede dos Firmewares da base e do sensor,

na variável “my_addr”. A plataforma Radiuino trabalha com o envio e recepção de

pacotes de 52 Bytes (de 0 a 51). Cada pacote contém uma informação e o

mapeamento dos pacotes, isto é, as informações que estão contidas em cada

pacote, pode ser encontrado no site do Radiuino (www.radiuino.cc) e em Anexo 3

dessa documentação. Por exemplo, para acionar o relé, é necessário alterar o estado

do Byte 43 de 0 para 1 e clicar em “Enviar”. Então, se uma lâmpada estiver ligada

nos terminais do relé, esta irá acender no nó sensor segundo a requisição feita pela

base. Para mais detalhes a respeito das informações carregadas nos Bytes, foi

anexado o mapeamento dos pacotes no final deste documento. As informações

podem ser visualizadas no Anexos 3.

21

Fig.15. Software RadiuinoTest.

6.2. Software de controle em PYTHON

O software PYTHON pode ser adquirido no site do Radiuino e é uma

alternativa ao software RadiuinoTest. A Figura 16 ilustra a simples interface do

software PYTHON. O código foi disponibilizado na Seção Anexos 4. Para iniciar a

aplicação é necessário pressionar a tecla F5, pressionar ‘1’ para realizar as medidas

e inserir o número de medidas. O número de medidas diz respeito à quantidade de

vezes que a base irá coletar as informações do nó sensor. No exemplo da fig.16,

foram requisitadas 100 medições e, então, a base se comunicou com o nó sensor

100 vezes (foram transmitidos 100 pacotes e recebidos 100 pacotes). O resultado foi

ilustrado pela Figura 17. As siglas RSSIu (Received Signal Strength Indication Up) e

RSSId (Received Signal Strength Indication Down) representam as potências de

transmissão e de recepção, respectivamente. A terminação em Down é relativa ao

sinal enviado da base para o nó sensor (base - nó sensor). Já a terminação Up diz

respeito ao sinal enviado do nó sensor para a base (nó sensor – base). Existe,

também, a probabilidade do pacote enviado pelo transmissor não ser recebido pelo

Endereço do sensor

Iniciar a comunicação

22

receptor ou vice-versa. Nesse caso, a mensagem “Perda de pacote” ou “Erro” é

mostrada na interface do PYTHON.

Fig.16. Interface da aplicação em PYTHON.

23

Fig.17. Resultado da aplicação PYTHON.

24

7. Exemplo de aplicação

Nessa Seção foi apresentado um exemplo de aplicação envolvendo o relé

e o sensor de luminosidade LDR. Uma lâmpada foi ligada nos terminais “comum”

e normalmente aberto (NA) do relé. A baixa luminosidade do ambiente,

detectada pelo LDR, acarretou na ativação do relé que, por sua vez, promoveu o

acendimento da lâmpada. A Figura 18 mostra o esquemático do circuito. No

Firmeware do nó sensor, apresentado na Seção 5.4, deve ser habilitado

(retirando o comando de //) o seguinte trecho de código: if(pkt->IO3[0] == 1)

//não acontece nada

else if(pkt->IO3[0] == 0)

if(AD1< 100) //verifica se a luminosidade é menor do que 100

digitalWrite(IO3_PIN,HIGH); // liga a lâmpada

if(AD1>=100) // verifica se a luminosidade é maior do que 100

digitalWrite(IO3_PIN,LOW); // Desliga a lâmpada

Fig.18. Esquema de ligação do relé.

A Figura 19 ilustra a alteração feita no Firmeware do nó sensor. Tanto no

RadiuinoTest quanto no Phyton, a lâmpada acendeu para luminosidades abaixo

de 100. Já para luminosidades acima de 100, a lâmpada permaneceu apagada.

Além do controle da luminosidade através do LDR, foi possível ligar ou desligar a

lâmpada via RadiuinoTest ajustando o byte 43 para 1 ou 0, respectivamente.

25

Fig.19. Alteração no Firmeware do nó sensor.

26

8. Considerações finais e conclusão

O Kit com a placa DK101 foi desenvolvido de forma didática a todos os

que se interessam pela área de redes de sensores sem fio. As aplicações variam

de acordo com as especificações do projeto que, por sua vez, depende da

criatividade do projetista. A leitura desse documento é essencial para a utilização

do Kit. Foram apresentadas as plataformas nas quais o Kit foi baseado, um

tutorial razoavelmente detalhado e os softwares necessário para rodar as

aplicações.

Além da placa DK101, existem outras mais atualizadas como a DK102 e

DK105. Estas são contam com maiores variedades de sensores. Entretanto, a

leitura do que foi apresentado neste documento pode ser de grande ajuda para

os que se interessam pelas placas mais atuais.

27

Anexo 1

Pinagem do microcontrolador ATmega328.

Equivalência de pinagem entre Arduino e BEE900.

28

Anexo 2

Características do sensor de temperatura.

29

Características do sensor de luminosidade LDR.

30

Características do relé eletromecânico.

31

Anexo 3

Tabela 1 – Acréscimo das variáveis do Pacote redefinido na placa DK101.

32

Tabela 2 - Mapeamento dos pacotes

33

Anexo 4

Código Python RSSId, RSSIu, Temperatura e

Luminosidade

# PROGRAMA PARA APLICAÇÃO DO DK101

import serial

import math

import time

import struct

from time import localtime, strftime

# Configura a serial

# para COM# o número que se coloca é n-1 no

primeiro parâmetrso. Ex COM9 valor 8

n_serial = raw_input("Digite o número da serial = ")

#seta a serial

n_serial1 = int(n_serial) - 1

ser = serial.Serial(n_serial1, 9600,

timeout=0.5,parity=serial.PARITY_NONE) # seta

valores da serial

# Identificação da base

ID_base = raw_input('ID_base = ')

34

#tempo_amostra = raw_input('Tempo entre

amostras = ')

# Cria o vetor Pacote

Pacote =

# Cria Pacote de 52 bytes com valor zero em todas as

posições

for i in range(0,52): # faz um array com 52 bytes

Pacote[i] = 0

while True:

try:

contador_tot = 0

contador_pot = 0

potmediad = 0.0

potacumulad = 0.0

potmeddbd = 0.0

contador_err = 0

potmediau = 0.0

potacumulau = 0.0

potmeddbu = 0.0

PER = 0

35

# Imprime na tela o menu de opções

print 'Escolha um comandos abaixos e depois

enter'

print '1 - Realiza medidas:'

print 's - Para sair:'

Opcao = raw_input('Entre com a Opção = ')

# Limpa o buffer da serial

ser.flushInput()

# Coloca no pacote o ID_base

Pacote[10] = int(ID_base)

Pacote[37] = 1 #Liga o LDR

# Leitura de temperatura e luminosidade

if Opcao == "1":

ID_sensor = raw_input('ID_sensor = ') #

Identificação do sensor a ser acessado

Pacote[8] = int(ID_sensor) # Coloca no pacote o

ID_sensor

num_medidas = raw_input('Entre com o

número de medidas = ')

w = int(num_medidas)

filename1 =

strftime("Sensor_%Y_%m_%d_%H-%M-%S.txt")

36

print "Arquivo de log: %s" % filename1

S = open(filename1, 'w')

for j in range(0,w):

for k in range(0,52): # transmite pacote

TXbyte = chr(Pacote[k])

ser.write(TXbyte)

# Aguarda a resposta do sensor

time.sleep(0.3)

line = ser.read(52) # faz a leitura de 52 bytes

do buffer que recebe da serial pela COM

if len(line) == 52:

rssid = ord(line[0]) # RSSI_DownLink

rssiu = ord(line[2]) # RSSI_UpLink

#RSSI Downlink

if rssid > 128:

RSSId=((rssid-256)/2.0)-74

else:

RSSId=(rssid/2.0)-74

#RSSI Uplink

if rssiu > 128:

RSSIu=((rssiu-256)/2.0)-74

else:

37

RSSIu=(rssiu/2.0)-74

count = ord(line[12]) # contador de

pacotes enviados pelo sensor

# Leitura do AD0

ad0t = ord(line[16]) # tipo de sensor - no

caso está medindo temperatura

ad0h = ord(line[17]) # alto

ad0l = ord(line[18]) # baixo

AD0 = ad0h * 256 + ad0l

Vout = 0.003223 * AD0

TEMP = (Vout*100)-50

# Leitura do AD1

ad1t = ord(line[19]) # tipo de sensor - no

caso está medindo LDR

ad1h = ord(line[20]) # alto

ad1l = ord(line[21]) # baixo

AD1 = ad1h * 256 + ad1l

# Leitura do AD2

#ad2t = ord(line[22]) # tipo de sensor - no

caso está medindo LDR

#ad2h = ord(line[23]) # alto

#ad2l = ord(line[24]) # baixo

#AD2 = ad2h * 256 + ad2l

#Vten = 0.003223 * AD2 * 11

38

#Leitura do AD5

ad5t = ord(line[22])

ad5h = ord(line[23])

ad5l = ord(line[24])

AD5 = ad5h * 256 + ad5l

contador_pot=contador_pot+1

potmwd = pow(10,(RSSId/10))

potacumulad = potacumulad + potmwd

potmwu = pow(10,(RSSIu/10))

potacumulau= potacumulau + potmwu

print'Número do pacote = ',count, 'RSSI

DownLink = ', RSSId, ' RSSI UpLink ', RSSIu, ' Temp =

', TEMP, ' Luminosidade = ',AD1

print >>S,time.asctime(),' Número do

pacote = ',count, 'RSSI DownLink = ', RSSId, ' RSSI

UpLink ', RSSIu, ' Temp = ', TEMP, ' Luminosidade =

',AD1

else:

contador_err = contador_err + 1

print ' erro'

print >>S,time.asctime(),' erro'

ser.flushInput()

time.sleep(0.5)

39

contador_tot = contador_tot + 1

#time.sleep(1)

potmediad = potacumulad /contador_pot

potmeddbd = 10*math.log10(potmediad)

#print ' A Potência média de downlink foi:',

potmediad , ' mW'

print 'A Potência média de Downlink em dBm

foi:', potmeddbd,' dBm'

print >>S,time.asctime(),' A Potência média de

Downlink em dBm foi:', potmeddbd,' dBm'

potmediau = potacumulau /contador_pot

potmeddbu = 10*math.log10(potmediau)

#print ' A Potência média de Uplink foi:',

potmediau , ' mW'

print 'A Potência média de Uplink em dBm foi:',

potmeddbu,' dBm'

print >>S,time.asctime(),' A Potência média de

Uplink em dBm foi:', potmeddbu,' dBm'

PER = float(contador_err)/float(contador_tot)

print 'A PER foi de:', float(PER),'%'

print >>S,time.asctime(),'A PER foi de:',

float(PER),'%'

S.close()

40

if Opcao == "s" or Opcao == "S":# caso o caracter

digitado for s

ser.close() # fecha a porta COM

print 'Fim da Execução' # escreve na tela

break

except KeyboardInterrupt:

S.close()

ser.close()

break