pData = [0] * 25

Esta matriz de y valores, pData, é então usado para valores de anexação a partir do sensor no enquanto
ciclo. o enquanto laço mantém anexando os novos valores para este agrupamento de dados e refaz a trama com estas matrizes
actualizados para o X e y valores. Neste exemplo, estamos a acrescentar novos valores de sensor no final da matriz enquanto
remover simultaneamente o primeiro elemento da matriz para limitar o tamanho da matriz:

pData.append (flutuador (a0.read ())) del pData [0]

o set_xdata () e set_ydata () métodos são usados ​para atualizar o X e y eixos dados destas matrizes. Estes valores
atualizados são plotados usando o desenhar() método em cada iteração do enquanto ciclo:

l1.set_xdata ([i for i in xrange (25)]) l1.set_ydata (pData) # update

do pyplot.draw dados () # update a trama

Você também vai notar que estamos utilizando um xrange () função para gerar uma gama de valores de acordo com o
comprimento previsto, que é 25 no nosso caso. O trecho de código, [ i para i na xrange (25)], vai gerar uma lista de 25 números
inteiros que começam incrementalmente a 0 e terminam em 24.
Integrando parcelas na janela de Tkinter
Devido às capacidades de integração poderosos de Python, é muito conveniente para fazer a interface das parcelas
geradas pela matplotlib biblioteca com o Tkinter interface gráfica. No último exercício do capítulo anterior, integrado Tkinter com
pyFirmata para implementar o projeto de Capítulo 3 , O primeiro projeto - LEDs Motion-acionados, com a GUI. Neste
exercício, vamos estender essa integração ainda mais, utilizando matplotlib. Vamos realizar esta ação, utilizando o
mesmo circuito Arduino que temos vindo a utilizar neste capítulo e expandir o código que usamos no exercício
anterior. Enquanto isso, não estamos introduzindo quaisquer novos métodos neste exercício; em vez disso, estará
utilizando o que você aprendeu até agora. Abra o plotTkinter.py arquivo da pasta de código deste capítulo. Como
mencionado anteriormente, o programa utiliza três principais bibliotecas e interfaces los com os outros Python para
desenvolver uma excelente aplicação Python em Arduino. O primeiro ponto é a interface entre Tkinter e matplotlib. Como
você pode ver nas seguintes linhas de código, temos inicializado três objetos de botão, startButton, pauseButton, e exitButton,
para o Começar, Pausa, e Saída botões respectivamente:

startButton = Tkinter.Button (topo,

text = "Iniciar",
comando >startButton.grid (coluna = 1, linha = 2) = pauseButton
Tkinter.Button (topo,
text = "Pause",
comando >pauseButton.grid (coluna = 2, linha = 2) = exitButton
Tkinter.Button (topo,
text = "Exit",
comando >exitButton.grid (coluna = 3, linha = 2)

o Começar e Saída botões fornecem pontos de controle para matplotlib operações como a atualização do enredo
e fechar a trama através do respectivo onStartButtonPress () e
onExitButtonPress () funções. o onStartButtonPress () função também consiste no ponto de interface entre o matplotlib e
pyFirmata bibliotecas. Como você pode observar a partir do seguinte trecho de código, vamos começar a
atualizar a trama usando o desenhar() método e o Tkinter janela usando o atualizar() Método para cada
observação do A0 pino analógico, que é obtido usando o ler() método:

def onStartButtonPress ():

while True:
se flag.get ():
sono (1)
pData.append (flutuador (a0.read ())) pyplot.ylim ([0,
1]) del pData [0]

l1.set_xdata ([i for i in xrange (25)]) l1.set_ydata (pData) # update

do pyplot.draw dados () # update do top.update plot () else:
 flag.set (True) pausa

o onExitButtonPress () função implementa os Saída função como descrito pelo próprio nome. Ele fecha a pyplot e
a figura Tkinter janela antes desengatar a placa Arduino a partir da porta de série.

Agora, execute o programa depois de fazer as alterações apropriadas para o parâmetro porta Arduino. Você deve ser
capaz de ver uma janela em sua tela que é semelhante à exibida na imagem seguinte. Com esse código, agora você
pode controlar suas parcelas em tempo real usando o Começar e Pausa botões. Clique no Começar botão e começar a
rodar o botão do potenciómetro. Quando você clica no Pausa botão, você pode observar que o programa parou a tramar
novos valores. Enquanto Pausa for pressionado, ainda girando o botão não vai resultar em quaisquer alterações de
trama. Assim que você clicar no Começar botão novamente, você voltará a ver a get enredo atualizado com valores em
tempo real, descartando os valores gerados durante a pausa. Clique no Saída

botão para fechar com segurança o programa:

resumo
Neste capítulo, introduzimos dois principais paradigmas de programação Python: criar, ler e escrever arquivos usando Python
e ao mesmo tempo armazenar dados em esses arquivos e traçando valores do sensor e atualizar lotes em tempo real. Nós
também explorou métodos para armazenar e trama em tempo real Arduino sensor de dados. Além de ajudar você em seus
projetos Arduino, esses métodos também podem ser usados ​em seus projetos Python diárias. Ao longo do capítulo, usando
exercícios simples, nós interface do CSV recém aprendidas e matplotlib módulos com o

Tkinter e pyFirmata módulos que aprendemos nos capítulos anteriores. No próximo capítulo, você será introduzido
para o seu segundo projecto unidade portátil que mede e exibe dados ambientais, como temperatura,
umidade e luz ambiente. Estaremos utilizando os conceitos que aprendemos até agora para construir este
projeto.
Capítulo 7. O Projeto Midterm - um portátil
DIY Termostato
Após o primeiro projeto Python em Arduino, você aprendeu o processo de prototipagem vários sensores, desenvolvimento de
interfaces de usuário, e traçando dados do sensor. Os conceitos que você aprendeu nos capítulos anteriores podem ser
utilizados para criar uma ampla variedade de projetos de hardware baseado em Arduino. A criação de um conceito de boa
aplicação sempre começa com uma necessidade do mundo real e acaba como um projeto prático se for executado
corretamente. Neste capítulo, vamos demonstrar este processo de construção de projeto com um exemplo de uma unidade de
sensor portátil. Como você pode estimar a partir do título do capítulo, estaremos construindo um simples e termostato DIY portátil
que pode ser implantado sem um computador desktop ou um laptop. Para começar, vamos descrever o termostato proposta com
metas e processos para alcançá-los específicos. Uma vez que a estratégia para alcançar essas metas foi estabelecido, você
será introduzido para os dois estágios sucessivos de programação para desenvolver a unidade implementável e portátil. Na
primeira etapa, vamos utilizar um computador tradicional para desenvolver com sucesso o programa de interface Arduino com
Python. Na segunda etapa, que irá substituir este computador com um Raspberry Pi para torná-lo portátil e destacável.
Termostato - a descrição do projeto
A partir dos vários projetos que podemos construir usando as coisas que você aprendeu, um projeto que ajuda a monitorar seu
ambiente circundante realmente se destaca como uma importante aplicação no mundo real. Dos vários projetos de monitoramento
de ambiente, tais como estação meteorológica, termostato, e sistema de monitoramento de plantas, estaremos desenvolvendo o
termostato como ele se concentra em ambiente interno e pode ser parte de sua rotina diária. O termostato é um dos mais
importantes componentes de qualquer casa remoto do sistema e sistema de automação residencial monitoramento. Um exemplo
comercial popular de um termostato ligado é o ninho termostato ( https://www.nest.com ), Que fornece recursos inteligentes de
monitoramento e agendamento remoto para o aquecimento da sua casa existente e sistema de arrefecimento. Antes de
pensarmos em um produto full-stack, como Ninho, precisamos de primeira necessidade para construir um termostato DIY com o
conjunto básico de características. Mais tarde, podemos construir em cima deste projeto, adicionando recursos para melhorar a
experiência do termostato DIY. Vamos primeiro esboço as características que estamos planejando implementar nesta versão do
projeto termostato.
Histórico do projeto
Temperatura, umidade e luz ambiente são as três principais características físicas que deseja monitorar usando o
termostato. Em termos de experiência do usuário, queremos ter uma interface de usuário elegante para exibir os
dados do sensor medida. A experiência do usuário pode ser mais engenhoso, se qualquer um desses dados do
sensor é plotado como um gráfico de linha. No caso de um termostato, a representação visual dos dados do
sensor proporciona uma compreensão mais significativa do ambiente do que apenas exibir valores numéricos
simples. Um dos principais objetivos do projeto é fazer com que o termostato tão portátil e destacável que pode ser
usado em seu dia-a-dia. Para satisfazer este requisito, as necessidades de exibição do termostato de ser alterado
de um monitor regular para algo pequeno e mais portátil. Para garantir a sua aplicação no mundo real e
significativa,

É importante notar que o termostato não será interface com quaisquer actuadores, tais como arrefecimento em casa e os
sistemas de aquecimento. Como a interface destes sistemas com o projeto termostato exige compreensão e experiência
de trabalhar com sistemas de aquecimento e arrefecimento de alto nível, ele irá desviar o fluxo do capítulo de seu
objetivo original de ensinar-lhe Arduino e Python programação.
objetivos e etapas do projeto
Para descrever as características que queremos ter no termostato, vamos primeiro identificar os objetivos e metas
para alcançar estes objectivos. As principais metas para o projeto pode ser determinada como segue:

Identificar os sensores necessários e componentes de hardware para o projeto projetar e montar o

circuito para o termostato usando estes sensores e a placa Arduino

Projetar uma experiência de usuário eficaz e desenvolver software para acomodar a experiência do usuário

Desenvolver e implementar código para a interface do hardware projetado com os componentes de software

O processo de desenvolvimento de código do projeto termostato é dividido em duas fases principais. Os objectivos da
primeira fase incluem sensor de interface, o desenvolvimento do esboço Arduino, eo desenvolvimento do código
Python em seu computador regular que você tem usado o tempo todo. O marco de codificação para a primeira fase
pode ser ainda distribuídas como se segue:

Desenvolver o esboço Arduino para sensores de interface e teclas, proporcionando a saída dos dados do sensor para o
programa Python através da porta serial desenvolver o código Python para obter dados do sensor a partir da porta de
série usando o
pyserial biblioteca e exibir os dados usando GUI que é projetado em Tkinter
Crie um gráfico para demonstrar as leituras de umidade em tempo real usando o matplotlib
biblioteca

Na segunda etapa, vamos anexar o hardware Arduino a um computador de placa única e uma exibição em miniatura
para torná-lo móvel e destacável. O marco para atingir o objectivo da segunda fase são como se segue:

Instalar e configurar um computador de placa única, Raspberry Pi, para executar o código Python da primeira fase

Interface e configurar a tela em miniatura com o Raspberry Pi Optimize janela GUI e enredo para ajustar a
resolução deste pequeno ecrã Na subsecção seguinte desta seção, você será notificado sobre a lista de
componentes necessários para ambas as etapas, seguido pelo hardware projeto de circuito eo design de fluxo de
software. Os exercícios de programação para estes estágios são explicados nas próximas duas seções do
capítulo.
A lista de componentes necessários
Em vez de passar pelo processo de identificação dos componentes necessários, já selecionou os componentes para este
projeto baseado em sua utilização nos exercícios anteriores, facilidade de utilização e disponibilidade. Você pode substituir
esses componentes de acordo com sua disponibilidade no momento você está construindo este projeto ou sua familiaridade
com outros sensores. Apenas certifique-se que você tome cuidado de modificações nas conexões de circuito e código, se
esses novos componentes não são compatíveis com os que estamos usando. Na primeira fase de prototipagem, vamos
precisar de componentes para desenvolver o circuito eletrônico para a unidade de termostato. Como mencionamos
anteriormente, nós estamos indo para medir a temperatura, umidade e luz ambiente através da nossa unidade. Nós já
aprendeu sobre o sensor de temperatura e o TMP102 BH1750 sensor de luz ambiente em Capítulo 4 , Mergulho em Python-
Arduino Prototipagem. Iremos utilizar estes sensores para este projecto com a HIH-4030 sensor de humidade. O projeto
utilizará a mesma placa Arduino Uno que têm vindo a utilizar ao longo dos capítulos anteriores com os cabos necessários.
Também vai precisar de dois botões de pressão para fornecer entradas manuais para a unidade. O resumo dos
componentes necessários para a primeira etapa é fornecida na tabela seguinte:

Componente (primeira fase) Quantidade site

Arduino Uno 1 https://www.sparkfun.com/products/11021

cabo USB para Arduino 1 https://www.sparkfun.com/products/512

placa de ensaio 1 https://www.sparkfun.com/products/9567

um sensor de temperatura TMP102 https://www.sparkfun.com/products/11931

HIH-4030 sensor de humidade 1 https://www.sparkfun.com/products/9569

BH1750 sensor de luz ambiente 1 http://www.robotshop.com/en/dfrobot-light-sensor-bh1750.html

Pressionar no interruptor 2 https://www.sparkfun.com/products/97

1 quilo-ohm 2

10 quilo-ohm 2

fios de ligação Como requerido

Embora a tabela fornece links para alguns site específico, você pode obter esses componentes de seus fornecedores
preferenciais. Os dois componentes principais HIH-4030 sensor de humidade e interruptor de botão de pressão que não tenham
usado anteriormente são descritos como se segue:

HIH-4030 sensor de humidade: Esta medidas e fornece os resultados de humidade relativa como uma saída analógica.
A saída do sensor pode ser directamente ligado a qualquer pino de analógico Arduino. O seguinte mostra a imagem da
placa de desagregação com a HIH-4030
sensor que é vendido por SparkFun Electronics. Você pode aprender mais sobre o sensor HIH-4030 a partir de sua folha de
dados, que pode ser obtido a partir de
https://www.sparkfun.com/datasheets/Sensors/Weather/SEN-09569-HIH-4030- datasheet.pdf :

Pressionar no interruptor: interruptores de botão de pressão são pequenas chaves que podem ser usados ​em uma placa de

ensaio. Quando pressionado, a saída interruptor muda seu status para ALTO, qual é

BAIXO de outra forma.

Na segunda etapa, vamos fazer a unidade de sensor móvel, substituindo o computador com um Raspberry Pi.
Para isso, você vai precisar dos seguintes componentes para começar:

O componente (segunda fase) Quantidade imagem

Raspberry Pi 1 https://www.sparkfun.com/products/11546

cabo micro USB com um adaptador de energia http://www.amazon.com/CanaKit-Raspberry-Supply-Adapter- Carregador / dp /

1
B00GF9T3I0 /

cartão de 8 GB SD 1 https://www.sparkfun.com/products/12998

tela LCD TFT 1 http://www.amazon.com/gp/product/B00GASHVDU/

Um concentrador USB Opcional

Mais explicações sobre estes componentes são fornecidos mais adiante neste capítulo.
design de hardware
A arquitetura de hardware inteira do termostato pode ser dividida em duas unidades, uma interface mundo unidade
física e uma unidade de computação. A unidade de interface mundo físico, como o seu nome indica, monitores
fenómeno do mundo físico, tais como a temperatura, humidade, e sensores de luz ambiente usando ligados à placa
Arduino. A unidade de interface mundo físico é indiferentemente referido como a unidade de sensor do termostato
durante todo o capítulo. A unidade computacional é responsável por exibir as informações do sensor através do GUI e
parcelas.

O diagrama a seguir mostra os componentes de hardware para a primeira fase, onde a unidade de sensor de
termostato é ligado a um computador usando a porta USB. Na unidade de sensor do termostato, vários componentes
do sensor está ligado à placa Arduino usando I2C, analógicos e digitais pinos:

Na segunda fase de programação onde vamos fazer o nosso termostato em uma unidade móvel e destacável, você
estará usando um computador de placa única, Raspberry Pi, como o dispositivo computacional. Nesta etapa, vamos
usar uma miniatura transistor de filme fino visor de cristal líquido- (TFT LCD) tela que está conectado a um
Raspberry Pi via entrada de uso geral / saída (GPIO) pinos e é usado como uma unidade de exibição para substituir o
monitor tradicional ou a tela do portátil. O diagrama a seguir mostra essa nova unidade computacional termostato, que
realmente reduz o tamanho total do termostato e torna portátil e móvel. conexões do circuito para a placa Arduino
estão inalterados para esta fase e vamos usar o mesmo hardware sem grandes modificações.
À medida que a unidade comum para ambas as etapas do projecto, a unidade de sensor do termostato Arduino centrada
requer ligações do circuito ligeiramente mais complexo em comparação com outros exercícios que tenha sido completamente.
Nesta seção, vamos fazer a interface dos sensores necessários e botões para os seus respectivos pinos na placa Arduino e
você vai precisar de uma placa de ensaio para fazer essas conexões. Se você está familiarizado com prototipagem PCB, você
pode criar sua própria placa PCB soldando esses componentes e evitar a placa de ensaio. placas PCB são mais robustos em
comparação com breadboards e menos propenso a perder conexões. Use as seguintes instruções e o diagrama Fritzing para
completar as ligações do circuito:

1. Como você pode ver no diagrama a seguir, conecte os pinos SDA e SCL de TMP102 e BH1750 aos pinos
analógicos 4 e 5 da placa Arduino e criar um barramento I2C. Para fazer essas conexões, você pode usar vários
fios codificados por cores para simplificar o processo de depuração.

2. resistências pull-up Uso dois 10 quilo-ohm com as linhas de SDA e SCL.

3. Contrariamente a estes sensores I2C, o sensor de humidade HIH-4030 é um sensor analógico simples e pode ser
directamente ligado ao pino analógico. Ligue o HIH-4030 para o pino analógico A0.

4. Ligação VCC e a terra de TMP102, BH1750, e HIH-4030 a + 5V e a terra da placa Arduino usando tiras de
alimentação da placa de ensaio, como mostrado no diagrama. Recomendamos que você use fios vermelho e
preto para representar a + 5V e linhas terrestres, respectivamente.

5. O botão fornece a saída como ALTO ou BAIXO Estado e com interface usando
pinos digitais. Como apresentado no circuito, de ligar esses botões de pressão para pinos digitais 2 e 3, utilizando duas

resistências de 1 quilo-ohm.

6. Complete as ligações restantes tal como apresentado no diagrama a seguir. Faço

 Certifique-se que você tenha conectado firmemente todos os fios antes de ligar a placa Arduino:

Nota

Certifique-se de que você desligue sempre sua placa Arduino da fonte de alimentação ou a uma porta USB
antes de fazer conexões. Isso irá evitar qualquer dano à placa devido a curtos-circuitos.

Completar todas as conexões para a unidade de sensor termostato antes de ir para a próxima seção. Como esta unidade está

sendo usada em ambos os estágios de programação, você não estará realizando quaisquer outras alterações para a unidade de

sensor termostato.
fluxo de software para design de experiência do usuário
Um dos componentes críticos de qualquer projeto é a sua usabilidade e acessibilidade. Quando você está trabalhando
em fazer o seu protótipo de projeto em um produto, é necessário ter uma interface de usuário intuitiva e recursos para
que o usuário pode facilmente interagir com o seu produto. Por isso, é necessário definir a experiência do usuário e fluxo
de um projeto de software antes de iniciar a codificação. O fluxo de software inclui o fluxograma e os componentes
lógicos do programa que são derivados a partir dos requisitos do projecto. De acordo com as metas que definimos para o
projeto do termostato, o fluxo de software pode ser demonstrado no diagrama a seguir:

Na aplicação, o fluxo do projecto do software começa através da medição da temperatura, humidade e luz
ambiente de Arduino e imprimi-los em uma porta serial
linha por linha. O programa Python obtém os dados dos sensores a partir de Arduino via a porta serial antes de apresentar os
dados no ecrã. Enquanto isso, o programa Python continua à procura de uma nova linha de dados.

Um usuário pode interagir com o termostato usando um botão de pressão, o que permitirá a mudança do usuário da unidade para os

dados de temperatura. Uma vez que o botão é pressionado, a bandeira é alterado para

ALTO e a unidade de temperatura é alterada para Celsius a partir de sua unidade padrão, Fahrenheit. Se o botão for pressionado
novamente, o processo oposto vai acontecer e a unidade será alterado novamente para seu valor padrão. Da mesma forma, outro
ponto de interação com o usuário é o segundo botão que permite que um usuário a abrir um enredo para valores de umidade em
tempo real. O segundo botão também utiliza um método semelhante de usar bandeiras para capturar a entrada e abre uma nova
janela trama. Se o mesmo botão é pressionado sequencialmente, o programa irá fechar a janela do enredo.
Fase 1 - prototipagem o termostato
Nesta fase de prototipagem, iremos desenvolver o código Arduino e Python para o nosso termostato, que será utilizado
mais tarde na segunda etapa com pequenas alterações. Antes de iniciar o exercício de codificação, certifique-se de que
você tem a unidade de sensor termostato pronto com a placa Arduino e os sensores conectados, como descrito na seção
anterior. Para este estágio, você estará usando o seu computador regular, que é equipado com o Arduino IDE e o ambiente
de programação Python. A fase de prototipagem requer dois níveis de programação, o esboço Arduino para a unidade de
sensor do termostato e o código Python para a unidade computacional. Vamos começar com a codificação para o nosso
termostato.
O esboço Arduino para o termostato
O objetivo deste programa Arduino é a interface sensores, obter medições dos sensores, e imprimi-los na
porta serial. Como discutimos anteriormente, em vez de usar o esboço Firmata padrão que usamos no
projeto anterior, vamos desenvolver um costume Arduino esboço neste projeto. Para começar, a céu aberto Thermostat_

esboçar a partir da pasta de código deste capítulo, que faz parte do código-fonte que você recebeu para o livro.

Ligue a porta USB da placa Arduino, que agora faz parte da unidade de sensor termostato, para o seu
computador. Selecione a bordo apropriado e nomes de porta no Arduino IDE e verificar o código. Carregar o
código para sua placa Arduino e ao ar livre Serial monitor
janela uma vez que o código é enviado com sucesso. Você deve ser capaz de ver texto semelhante ao exibido
na imagem seguinte:

A estrutura do código Arduino e declarações básicas já são explicados em várias seções ao longo do livro. Em vez de
explicar todo o código linha por linha, vamos nos concentrar aqui sobre os principais componentes do fluxo de
software que descrevemos anteriormente.

Interface entre o sensor de temperatura

No esboço Arduino, a temperatura de dados é obtido a partir do sensor de TMP102 usando o

getTemperature () função. A função implementa o Fio biblioteca no endereço I2C de TMP102 para ler os dados do
sensor. Este é, então, convertida em valores de temperatura adequadas:

flutuar getTemperature () {
Wire.requestFrom (tmp102Address, 2);

byte MSB = Wire.read ();

 byte LSB = Wire.read ();

// é um int de 12 bits, usando elogio dois para int negativo TemperatureSum = ((MSB << 8) | LSB)
>> 4;

flutuador Celsius = TemperatureSum * 0,0625; voltar celsius; }

o getTemperature () função retorna os valores de temperatura em graus Celsius, a qual é então enviado para a porta de série.

Interface entre o sensor de humidade

Embora o sensor de humidade proporciona a saída analógica, não é fácil de obter de humidade relativa,
uma vez que também depende da temperatura. o getHumidity ()
calcula a humidade relativa da saída analógica fornecida pelo sensor HIH- 4030. As fórmulas para calcular a
humidade relativa são obtidos a partir dos exemplos folha de dados e de referência do sensor. Se você estiver
usando um sensor de umidade diferente, por favor certifique-se de alterar as fórmulas de acordo, uma vez que
podem alterar significativamente os resultados:

flutuar getHumidity (flutuador degreesCelsius) {// caculate humidade

relativa flutuador supplyVolt = 5,0;

// Obter o valor do sensor:

int HIH4030_Value = analogRead (HIH4030_Pin); // convertido ao valor de
tensão
tensão de flutuação = HIH4030_Value / 1023. * SupplyVolt;

// converter a tensão a um flutuador de humidade relativa sensorRH = 161,0 * tensão / supplyVolt - 25,8;
flutuar trueRH = sensorRH / (1,0546-0,0026 * degreesCelsius);

voltar trueRH; }

À medida que são cálculo de humidade relativa, os valores de humidade retornados são enviados para a porta serial com percentual

para a unidade.

Interface entre o sensor de luz

A interface do sensor de luz BH1750, usaremos a biblioteca BH1750 Arduino, que usamos anteriormente. A utilização desta
biblioteca, o valor de luz ambiente pode ser directamente obtida usando a seguinte linha de código:

uint16_t lux = lightMeter.readLightLevel ();

Esta linha fornece os valores de luminância na unidade de Luxo. Estes valores também são enviados para a porta serial para que o

programa Python pode utilizá-lo ainda mais.

Usando interrupções Arduino

Até agora você usou o programa Arduino para ler o estado físico de um pino de I / O usando o
DigitalRead () ou AnalogRead () funções. Como você obter automaticamente a mudança de estado em vez de ler
periodicamente os pinos e esperando para o estado para a mudança? interrupções Arduino fornecem uma maneira
muito conveniente de capturar sinais para a placa Arduino. Interrupções são uma forma muito poderosa de controlar
automaticamente várias coisas no Arduino. suporta interrupções Arduino usando o attachInterrupt () método. Em termos dos
pinos físicas, Arduino Uno fornece duas interrupções: interrupção 0 (no pino digital 2) e interrupção de 1 (no pino digital
3). Várias placas Arduino têm especificações diferentes para pinos de interrupção. Se você estiver usando qualquer
placa que não seja Uno, por favor consulte o site do Arduino para saber mais sobre o pino de interrupção para a sua
placa. o attachInterrupt () função recebe três argumentos de entrada ( pino, ISR, e modo). Nesses argumentos de entrada, PIN refere-se
ao número do pino de interrupção, ISR ( que significa interrupção Service rotina) refere-se à função que é chamada
quando a interrupção ocorrer, e modo define a condição quando a interrupção deve ser acionado. Temos utilizado esta
função no nosso programa Arduino, como descrito no seguinte trecho de código:

attachInterrupt (0, button1Press, elevando-se); attachInterrupt (1,

button2Press, elevando-se);

o suportada modo para attachInterrupt () estamos LOW, MUDANÇA, subindo, e QUEDA. No nosso caso, as interrupções são
acionados quando o modo é AUMENTAR, isto é, o pino passa de baixo para cima. Para interrupções declarou em 0 e
1, que chamamos de button1Press e button2Press
funções que mudarão flagTemperature e flagPlot respectivamente. Quando
flagTemperature está configurado para ALTO, Arduino envia a temperatura em graus Celsius, caso contrário, ele envia a
temperatura em graus Fahrenheit. Quando flagPlot é ALTO, Arduino irá imprimir a bandeira na porta serial, que será usado pelo
programa de Python mais tarde para abrir a janela de trama. Você pode aprender mais sobre as interrupções Arduino do
tutorial em
http://arduino.cc/en/Reference/attachInterrupt .
Projetando a GUI e trama em Python
Uma vez que sua unidade de sensor termostato começa a enviar dados do sensor à porta serial, é hora de
executar a segunda parte desta etapa, o código Python para o GUI e o enredo. Da pasta de código deste capítulo,
abra o arquivo Python chamada Thermostat_Stage1.py. No arquivo, vá até a linha que contém o Serial() função onde a
porta serial é declarada. Alterar o nome da porta serial do COM5 para o apropriado. Você pode encontrar essa
informação do Arduino IDE. Salvar a alteração e saia do editor. A partir da mesma pasta, execute o seguinte
comando no terminal:

$ Python Thermostat_Stage1.py

Isto irá executar o código Python e você será capaz de ver a janela de GUI na tela.

Usando pyserial para transmitir dados dos sensores em seu programa Python

Tal como descrito no fluxo de software, o programa recebe os dados do sensor a partir do Arduino usando o pyserial biblioteca.
O código que declara a porta serial do código Python é como se segue:

importação de série
porto = serial.Serial ( 'COM5', 9600, tempo limite = 1)

É muito importante para especificar o tempo esgotado parâmetro durante a utilização do pyserial biblioteca, como o código pode ter um
erro se tempo esgotado não é especificado.

Projetando a GUI usando Tkinter

A GUI para este projecto foi concebido usando o Tkinter biblioteca que usamos anteriormente. Como um exercício de GUI,
três colunas de etiquetas (labels para exibir o tipo de sensor, os valores de observação, e unidades de observação) são
programados como se mostra no seguinte fragmento de código:

# Etiquetas para nome do sensor

Tkinter.Label (topo, texto = "temperatura"). Grade (coluna = 1, linha = 1) Tkinter.Label (topo, texto = "Humidade").
Grade (coluna = 1, linha = 2) Tkinter.Label ( top, text = "Light"). grade (coluna = 1, linha = 3)

# Etiquetas para valores de observação

TempLabel = Tkinter.Label (topo, texto = " ") TempLabel.grid (coluna = 2,
linha = 1) HumdLabel = Tkinter.Label (topo, texto ="") HumdLabel.grid
(coluna = 2, linha = 2) LighLabel = Tkinter.Label (topo, texto = " ")
LighLabel.grid (coluna = 2, linha = 3)

# Etiquetas para unidade de observação

TempUnitLabel = Tkinter.Label (topo, texto = " ") TempUnitLabel.grid (coluna = 3,
linha = 1) HumdUnitLabel = Tkinter.Label (topo, texto = "%") HumdUnitLabel.grid
(coluna = 3, fila 2 = ) LighUnitLabel = Tkinter.Label (em cima, text = "lx")
LighUnitLabel.grid (coluna = 3, linha = 3)

Uma vez que você inicializar o código e antes de clicar no Começar botão, você será capaz de ver a seguinte janela.
Os rótulos de observação são preenchidos sem quaisquer valores nesta fase:

Uma vez o Começar botão é clicado, o programa irá envolver a unidade de sensor termostato e começar a ler os
valores do sensor da porta serial. Usando as linhas que são obtidos a partir da porta serial, o programa irá preencher
as etiquetas de observação com os valores obtidos. O seguinte trecho de código atualiza os valores de temperatura no
rótulo observação e também atualiza a unidade de temperatura:

TempLabel.config (text = cleanText (leitura [1])) TempUnitLabel.config (text = "C")

TempUnitLabel.update_idletasks ()

No programa, estamos usando métodos semelhantes para umidade e luz ambiente para atualizar seus rótulos
respectivamente. Como se pode ver na imagem seguinte, a GUI agora tem os valores para a temperatura, humidade,
e leituras de luz ambiente:

o Começar e Saída botões são programados para chamar a onStartButtonPress () e

onExitButtonPress () funções quando são clicados pelo usuário. o
onStartButtonPress () função executa o código necessário para criar a interface do usuário, enquanto o onExitButtonPress
() função fecha todas as janelas abertas, desconecta a unidade de sensor termostato, e sai do código:

StartButton = Tkinter.Button (topo,

text = "Iniciar",
comando >StartButton.grid (coluna = 1, fila 4 =) = exitButton
Tkinter.Button (topo,
text = "Exit",
comando >ExitButton.grid (coluna = 2, fila 4 =)
Você pode jogar com o Começar e Saída botões para explorar o código Python. Para observar as mudanças nas leituras do
sensor, tente soprar ar ou colocar um obstáculo sobre a unidade de sensor do termostato. Se o programa não se comportar
adequadamente, verifique o terminal para mensagens de erro.

Traçando percentagem de humidade usando matplotlib

Nós vamos usar o matplotlib biblioteca para traçar os valores de umidade relativa em tempo real. Vamos traçar os valores de
humidade relativa neste projecto, como o intervalo de dados é fixo entre 0 e 100 por cento. Utilizando um modo semelhante,
também é possível traçar valores do sensor de luz ambiente e de temperatura. Ao desenvolver o código para temperatura
enredo e dados sensor de luz ambiente, certifique-se que você está usando faixas apropriadas para cobrir os dados do
sensor na mesma trama. Agora, como já especificado no onStartButtonPress () função, uma janela semelhante à imagem a seguir
irá aparecer depois de premir o botão de pressão para a trama:

O fragmento de código seguinte é responsável para traçar o gráfico de linha utilizando os valores do sensor de
humidade. Os valores estão limitados entre 0 e 100 na y eixo, onde o y eixo representa a gama de humidade relativa. O
enredo é atualizada a cada vez que o programa recebe um novo valor de umidade:

pyplot.figure ()
pyplot.title ( 'Humidade') AX1 = pyplot.axes
() L1, = pyplot.plot (pData) pyplot.ylim
([0100])
Usando interrupções botão para controlar os parâmetros

As interrupções de botão de pressão é uma parte crítica da experiência do utilizador, como o utilizador pode controlar a unidade de

temperatura e a trama usando essas interrupções. O Python funcionalidades implementadas utilizando o botão interrupções são os

seguintes.

Alterando a temperatura unidade, premindo um botão

O esboço Arduino contém a lógica de interrupções alça de botões e usá-los para alterar a unidade de temperatura.
Quando uma interrupção ocorre, em vez de imprimir a temperatura em graus Fahrenheit, ele envia a temperatura em
graus Celsius para o porta serial. Como você pode ver na imagem seguinte, o código Python imprime apenas o valor
numérico obtido da observação temperatura e a unidade de medição associada com ele:

Como você pode ver no seguinte trecho de código, se o código Python recebe o
Temperatura (C) cadeia, que imprime a temperatura Celsius, e se ele recebe o
Temperatura (F) cadeia, que imprime a temperatura Fahrenheit: if (leitura [0] ==

"Temperatura (C)"):
TempLabel.config (texto = cleanText (lendo [1]))
TempUnitLabel.update_idletasks (TempUnitLabel.config (texto = "C")) if (lendo
[0] == "Temperatura (F)"):

TempLabel.config (text = cleanText (leitura [1]))

TempUnitLabel.update_idletasks TempUnitLabel.config (text = "F") ()

Alternar entre o GUI eo enredo pressionando um botão

Se o código Python recebe o valor da bandeira da porta serial como 1 ( ALTA), cria-se uma nova trama e extrai os valores de
humidade como um gráfico de linhas. No entanto, ele fecha quaisquer parcelas em aberto se ele recebe 0 ( LOW) como o valor da
bandeira. Como você pode ver no seguinte trecho de código, o programa irá sempre tentar atualizar o lote com as últimas valores
para leituras de umidade. Se o programa não pode encontrar uma trama aberta para desenhar esse valor, ele irá criar um novo
lote:

if (leitura [0] == "Flag"):

leitura de impressão [1]
if (int (leitura [1]) == 1):
experimentar: l1.set_xdata (np.arange (len (pData)))

l1.set_ydata (pData) # update do pyplot.ylim dados ([0, 100])

pyplot.draw () # update a trama

 exceto:
pyplot.figure ()
pyplot.title ( 'Humidade') AX1 = pyplot.axes
() L1, = pyplot.plot (pData) pyplot.ylim ([0,
100]) if (int (lendo [1]) == 0):

experimentar: pyplot.close ( 'all')

L1 = Nenhuma,
excepto:

Até agora, você deve ter uma ideia completa sobre os programas que são exigidos pela unidade de sensor termostato e a
unidade de computação. Devido à complexidade envolvida, você pode enfrentar alguns problemas conhecidos durante a
execução desses programas. Você pode consultar a
Solução de problemas seção no caso de você topar com algum problema.
Solução de problemas
Aqui estão alguns dos erros que você pode encontrar, e suas correções:

sensor de I2C retorna a string de erro:

Verifique as conexões para os pinos SDA e SCL.

Confirmar que você está fornecendo atraso suficiente entre os ciclos de leitura do sensor. Verifique a folha

de dados para a seqüência de atraso e mensagem. A janela enredo pisca em vez de ficar ligado quando o

botão é pressionado:

Não tente pressioná-lo várias vezes. Segurar e soltou rapidamente. Certifique-se que o botão está ligado
corretamente. Ajustar o atraso no esboço Arduino.
Fase 2 - usando um Raspberry Pi para o termostato
implementável
Temos agora criado um termostato que existe como um protótipo Arduino enquanto o programa Python executado a partir
do seu computador. Este protótipo ainda está longe de um estado móveis ou móvel devido ao computador conectado, eo
monitor, se você estiver usando um computador desktop. Um mundo real termostato dispositivo deve ter uma pegada
pequena, tamanho portátil, e exibição em miniatura para mostrar informações limitadas. A maneira popular e prático para
alcançar este objetivo é usar um pequeno computador de placa única que é capaz de hospedar um sistema operacional e,
portanto, fornecer a interface essencial de programação Python. Para esta etapa do projeto, estaremos utilizando um único
computador de bordo, um Raspberry Pi-com um pequeno visor LCD.

Nota

Note-se que esta etapa do projeto é opcional a menos que você deseja estender a fase anterior do projeto de um dispositivo

que pode ser usado em uma base regular. Se você está se referindo ao projeto apenas para aprender programação Python,

você pode pular esta seção inteira. O seguinte é uma imagem do Raspberry Pi Modelo B:

Se você ainda não trabalhou com um computador de placa única antes, você pode ter um monte de perguntas sem
resposta, como “O que exatamente faz um Raspberry Pi consiste?”, “Quais são os benefícios de usar um Raspberry Pi
em nosso projeto ?”, e‘não podemos apenas usar Arduino para isso?’. Estas são questões legítimas e vamos tentar
respondê-las da seguinte
seção.
O que é um Raspberry Pi?
O Raspberry Pi é um pequeno (quase do tamanho de um cartão de crédito) de computador de placa única que foi
desenvolvido com o objetivo inicial de ajudar os alunos a aprender as noções básicas de informática. Hoje, o movimento
Raspberry Pi, guiado pelo Pi Foundation Framboesa, se transformou em um fenômeno DIY e chamou a atenção dos
entusiastas e desenvolvedores ao redor do mundo. As capacidades e recursos fornecidos com um Raspberry Pi, a um
custo nominal (US $ 35) impulsionaram a popularidade do dispositivo.

O computador de placa única termo é usado para dispositivos que têm todos os componentes necessários para executar um
sistema operativo sobre uma placa, tal como um processador, a memória RAM, o processador de gráficos, dispositivo de
armazenamento e adaptadores de base para a expansão. Isso faz com que um computador de placa única um candidato
adequado para aplicações portáteis, como eles podem ser parte de hardware do dispositivo portátil que estamos tentando criar.
Embora houvesse um número de computadores de placa única no mercado antes da introdução do Raspberry Pi, a natureza de
código aberto do hardware eo preço econômico são as principais razões por trás da popularidade e rápida adoção do Raspberry
Pi. Os seguintes figura mostra a framboesa Pi Modelo B com os seus principais componentes:

As capacidades computacionais do Raspberry Pi são adequados para a execução de uma versão aparadas para baixo de Linux OS.

Embora as pessoas tinham tentado usar muitos tipos de sistemas operacionais em um Raspberry Pi, estaremos usando o padrão e

recomendado sistema operacional chamado Raspbian. Raspbian é uma fonte aberta baseada em distribuição Debian Linux OS, que é

otimizada para o Raspberry Pi. O Raspberry Pi usa um cartão SD como dispositivo de armazenamento, que será usado para armazenar

seus arquivos do sistema operacional e programas. Em Raspbian, você pode evitar a executar os componentes do sistema operacional

desnecessários que são fornecidos com sistemas operacionais tradicionais. Estes incluem o navegador de Internet, aplicativo de

comunicação e, em alguns casos, até mesmo a

interface gráfica.

Após sua introdução, o Raspberry Pi passou por algumas grandes atualizações. A versão anterior, chamada Modelo A, não
incluiu a porta Ethernet e só tinha uma memória de 256 MB. Em nosso projeto, estamos usando do Raspberry Pi Modelo
B que tem uma porta dedicada Ethernet, 512 MB de memória, e duas portas USB. As últimas versões do Raspberry Pi,
Modelo B +, também pode ser usado, como também é equipado com uma porta Ethernet.
Instalar o sistema operacional e configurar o Raspberry Pi

Embora o Raspberry Pi é um computador, é diferente do que os computadores desktop tradicionais quando se trata de
interface dispositivos periféricos. Em vez de apoiar portas VGA ou vídeo DVI tradicionais, a framboesa Pi fornece uma porta
de vídeo RCA para televisores e uma porta HDMI para a mais recente geração de monitores e de televisões. Além disso, o
Pi framboesa tem apenas duas portas USB que necessitam de ser utilizados para ligar vários dispositivos periféricos, tais
como o rato, o teclado, o adaptador USB sem fios, e o cartão de memória USB. Vamos começar pela coleta de
componentes e cabos para começar a trabalhar com um Raspberry Pi.

O que você precisa para começar a usar o Raspberry Pi?

Os componentes de hardware necessários para começar com um Raspberry Pi são os seguintes:

A Raspberry Pi: Para esta etapa do projeto, você vai precisar de um Raspberry Pi versão Modelo B ou mais recente.
Você pode comprar o Raspberry Pi de
http://www.raspberrypi.org/buy .
Um cabo de alimentação: O Raspberry Pi é executado em 5V DC e requer pelo menos 750 mA de corrente. A alimentação é

aplicada através da porta USB micro que está localizado na placa. Neste projeto, você vai precisar de uma fonte de alimentação

USB micro. Opcionalmente, você pode usar um carregador de telefone baseados em micro USB para fornecer energia para o

Raspberry Pi.

Um cabo de vídeo: Se você tem um monitor HDMI ou uma TV, você pode usar um cabo HDMI para conectá-lo ao seu
Raspberry Pi. Se você quiser usar o seu monitor VGA ou baseado em DVI, você vai precisar de um VGA para HDMI ou
DVI para HDMI conversor adaptador. Você pode comprar estes conversores adaptador de Amazon ou Best Buy.

Um cartão SD: Você é obrigado a ter pelo menos um cartão de 8 GB SD para começar. É preferível usar um cartão SD que tem

uma qualidade de classe 4 ou melhor. Você também pode comprar um cartão SD com o sistema operacional pré-instalado no

http://swag.raspberrypi.org/collections/frontpage/products/noobs-8gb-sd-card .

Nota

O Raspberry Pi Modelo B + requer um cartão microSD, em vez de um cartão SD regular.

Um mouse e teclado: Você vai precisar de um teclado USB padrão e um mouse USB para trabalhar com o
Raspberry Pi.
Um concentrador USB (opcional): Desde o Modelo B tem apenas duas portas USB, você terá que remover dispositivos
existentes das portas USB ao espaço make para outro dispositivo, se você quiser conectar um adaptador ou memória
vara Wi-Fi a ele. Um hub USB pode ser útil para anexar vários componentes periféricos para o Raspberry Pi.
Recomendamos que você use um hub USB com fonte de alimentação externa, como o Raspberry Pi pode dirigir um
número limitado de dispositivos periféricos através das portas USB devido a limitações de potência.

Preparar um cartão SD

Para instalar software e configurar os componentes, tais como Python e as bibliotecas necessárias, em primeiro lugar, precisamos de

um sistema operacional para o Raspberry Pi. A Raspberry Pi suporta oficialmente

Linux baseada em sistemas operacionais de código aberto que são pré-configurados para componentes de hardware
personalizado Raspberry Pi. Várias versões desses sistemas operacionais estão disponíveis no site do Raspberry Pi ( http://www.raspberryp
).

website do Raspberry Pi fornece uma variedade de sistemas operacionais para os usuários que vão desde iniciantes a especialistas. É

difícil para um usuário de primeira vez para identificar o sistema operacional apropriado e seu processo de instalação. Se esta é sua

primeira tentativa com um Raspberry Pi, recomendamos que você use o

New Out Of Box Software (NOOBS) pacote. Baixar a última versão do NOOBS
a partir do link anterior. o NOOBS pacote inclui alguns sistemas operativos diferentes, tais como Raspbian, Pidora,
Archlinux, e RaspBMC. NOOBS agiliza todo o processo de instalação e ajuda você a instalar e configurar a sua
versão preferida do OS facilmente. É importante notar que NOOBS é apenas um pacote de instalação e você vai ficar
com apenas o OS Raspbian uma vez que você completar as etapas de instalação dadas.

Raspberry Pi usa o cartão SD para hospedar o sistema operacional e você precisa preparar o cartão SD do seu computador
antes de colocá-lo no slot de cartão SD do Raspberry Pi. Insira o cartão SD no seu computador e certifique-se de que você
tem um backup de qualquer informação importante que está no cartão SD. Durante o processo de instalação, você perderá
todos os dados armazenados no cartão SD. Vamos começar a preparar o seu cartão SD. Siga estes passos para preparar
um cartão SD a partir do Windows:

1. Você vai precisar de uma ferramenta de software para o formato e prepare o cartão SD para Windows. Você pode baixar a ferramenta

formatação disponível gratuitamente em

https://www.sdcard.org/downloads/formatter_4/eula_windows/ .
2. Faça o download e instalar a ferramenta de formatação no seu computador Windows.

3. Insira seu cartão SD e iniciar a ferramenta de formatação.

4. Na ferramenta de formatação, abra o opções menu e conjunto Tamanho Formato
AJUSTAMENTO para EM.
5. Selecione o cartão SD apropriado e clique em Formato.
6. Em seguida, aguarde a ferramenta formatação para concluir a formatação do cartão SD. Uma vez feito isso, extrair o
baixado NOOBS arquivo ZIP para o cartão SD. Certifique-se de que você extraia o conteúdo da pasta ZIP para o local
raiz do cartão SD.

Siga estas instruções para preparar o cartão SD a partir do Mac OS X:

1. Você vai precisar de uma ferramenta de software para o formato e prepare o cartão SD para Mac OS X. Você pode baixar a

ferramenta formatação disponível gratuitamente em

https://www.sdcard.org/downloads/formatter_4/eula_mac/ .
2. Faça o download e instalar a ferramenta de formatação na sua máquina.

3. Insira seu cartão SD e executar a ferramenta de formatação.

4. Na ferramenta de formatação, selecione Formato de substituição.

5. Selecione o cartão SD apropriado e clique em Formato.

6. Em seguida, aguarde a ferramenta formatação para concluir a formatação do cartão SD. Uma vez feito isso, extrair o
baixado NOOBS arquivo ZIP para o cartão SD. Certifique-se de que você extraia o conteúdo da pasta ZIP para o local
raiz do cartão SD.
Siga estes passos para preparar o cartão SD do Ubuntu Linux:

1. Para formatar o cartão SD no Ubuntu, você pode usar uma ferramenta de formatação chamada GParted.

Instalar gparted usando o seguinte comando no terminal:

$ Sudo apt-get install GParted

2. Insira o cartão SD e correr GParted.

3. No gparted janela, selecione todo o cartão SD e formatá-lo usando FAT32.
4. Uma vez que o processo de formatação estiver concluída, extrair o baixado NOOBS arquivo ZIP para o

Cartão SD. Certifique-se de que você extraia o conteúdo da pasta ZIP para o local raiz do cartão SD.

Gorjeta

Se você tiver qualquer dificuldade para seguir estes passos, você pode consultar a documentação oficial
para preparar o cartão SD para um Raspberry Pi em
http://www.raspberrypi.org/documentation/installation/installing-images/ .

O processo de configuração Raspberry Pi

Depois de ter preparado o seu cartão SD com NOOBS, inseri-lo no slot de cartão SD do Raspberry Pi. Ligue o seu monitor,
mouse e teclado antes de conectar o cabo USB micro para o adaptador de energia. Uma vez que você conectar o adaptador
de alimentação, o Raspberry Pi irá ligar automaticamente e você será capaz de ver o processo de instalação no monitor. Se
você não é capaz de ver qualquer progresso no monitor depois de conectar o adaptador de energia, consulte a secção de
resolução de problemas que está disponível mais tarde neste capítulo. Uma vez que as botas Raspberry Pi, ele irá criar
partições no cartão SD e mostrar-lhe o ecrã de instalação do seguinte modo que você pode começar:
Nota

A imagem anterior é tomada a partir de raspberry_pi_F01_02_5a.jpg por Simon Monk e está licenciado sob
licença Attribution Creative Commons ( https://learn.adafruit.com/assets/11384 ).

1. Como um usuário de primeira vez, selecione Raspbian [RECOMENDADO] como o recomendado

sistema e clique operando no instale OS botão. Raspbian é um sistema operacional baseado em Debian que é
otimizado para o Raspberry Pi e suporta comandos Linux úteis que já aprendeu nos capítulos anteriores. O
processo vai demorar cerca de 10 a 20 minutos para completar.

2. Na conclusão bem sucedida, você será capaz de ver uma tela semelhante à exibida na imagem seguinte. A
imagem mostra os Raspi-config ferramenta que vai deixar você configurar os parâmetros iniciais. Vamos ignorar
este processo para concluir a instalação. Selecione < Concluir> e pressione Entrar:

3. Você pode voltar a esta tela novamente, no caso de você deseja alterar qualquer parâmetro, digitando o
seguinte comando no terminal:

$ Sudo Raspi-config

4. Raspberry Pi agora irá reiniciar e você será solicitado a tela de login padrão. Faça o login usando o
nome de usuário padrão pi e senha framboesa.
5. Você pode iniciar o ambiente gráfico do Raspberry Pi, digitando o seguinte comando no
terminal:

$ startx

6. Para executar o código Python que desenvolvemos na primeira etapa, você precisará configurar bibliotecas
Python necessários no Raspberry Pi. Você terá que conectar o Raspberry Pi à Internet usando o cabo
Ethernet para instalar os pacotes. Instalar os pacotes Python necessários no terminal Raspberry Pi
usando o seguinte comando:

$ Sudo apt-get install python-setuptools, python-matplotlib, python-

 numpy

7. Instale pyserial usando Setuptools:

$ Sudo easy_install pyserial

Agora, o Raspberry Pi está pronto com um sistema operacional e os componentes necessários para suportar a
programação Python em Arduino.
Usando um display TFT LCD portátil com o Raspberry
Pi
TFT LCD é uma ótima maneira de expandir as funcionalidades do o Raspberry Pi e evitar o uso de grandes dispositivos de
exibição. Estes monitores TFT LCD pode ser conectado diretamente com pinos GPIO. ecrãs TFT LCD estão disponíveis em
várias formas e tamanho, mas para o Raspberry Pi recomendamos que você usa uma tela com um tamanho menor ou igual a
3,2 polegadas devido à interface conveniência. A maioria dessas telas pequenas não necessitam de fonte de alimentação
adicional e pode ser diretamente alimentado usando os pinos GPIO. Em alguns casos, as versões de tela de toque também
estão disponíveis para estender a funcionalidade do Raspberry Pi. Neste projeto, estamos usando uma tela LCD TFT de 2,4
polegadas Tontec que podem ser diretamente interface com o Raspberry Pi via GPIO. Embora você possa usar qualquer tela
TFT LCD disponível, este livro só cobrem o processo de instalação e configuração para esta tela particular. Na maioria dos
casos, os fabricantes destas telas oferecem tutoriais de configuração detalhadas em seus sites. Framboesa fóruns e blogs Pi
são outros bons lugares para procurar ajuda se você estiver usando um tipo diferente da tela TFT LCD. Os seguintes imagem
mostra a parte de trás da tela TFT LCD Tontec 2,4 polegadas com a localização dos pinos GPIO. Vamos começar e usar
essa tela com o Raspberry Pi:

Ligar o LCD TFT usando GPIO

Antes de podermos usar a tela, vamos ter que conectá-lo ao Raspberry Pi. Vamos desligar o adaptador micro
alimentação USB do Raspberry Pi e localizar os pinos machos GPIO perto da porta de vídeo RCA sobre o
Raspberry Pi. Obtenha seu ecrã TFT e conectar os pinos GPIO, como tal, você pode ver Raspberry Pi e a tela
como mostrado na imagem a seguir. Em casos punhado, as anotações na tela será enganosa e, portanto,
sugerimos que você seguir as orientações do fabricante para fazer as conexões:
Uma vez que sua tela é ligada à Raspberry Pi, poder-lo usando o cabo USB micro. Não desligue o cabo HDMI ainda,
como a sua tela ainda não está pronto. Antes de ir em frente com qualquer um dos passos de configuração, vamos
primeiro conectar o Raspberry Pi à Internet. Ligue a porta Ethernet do Raspberry Pi à sua rede doméstica ou de
escritório usando um cabo Ethernet. Agora, vamos configurar a tela TFT LCD na Raspbian OS para que ele funcione
corretamente.

Configurando o LCD TFT com o Raspberry Pi OS

Uma vez que seu Raspberry Pi é ligado, faça o login usando seu nome de usuário e senha. Complete as
seguintes etapas para configurar a tela com o Raspberry Pi:

1. Faça o download dos arquivos de suporte e manual usando o seguinte comando no terminal:

$ Wget https://s3.amazonaws.com/tontec/24usingmanual.zip

2. Descompacte o arquivo. O seguinte comando irá extrair os arquivos no mesmo diretório:

$ 24usingmanual.zip unzip

3. Navegue até a src diretório:

$ Cd cd mztx-ext-2.4 / src /

4. Digite o comando seguinte para compilar os arquivos de origem:

 $ make

5. Abra os arquivos de configuração de inicialização:

$ Sudo pico /boot/config.txt

6. No config.txt arquivo, localize e remova o comentário das seguintes linhas de código:

framebuffer_width = 320 = 240

framebuffer_height

7. Salve e saia do arquivo.

8. Agora, cada vez que o Raspberry Pi reinicia precisamos para executar um comando para iniciar o ecrã TFT LCD.
Para fazer isso, abra o rc.local arquivo usando o seguinte comando:

$ Sudo pico /etc/rc.local

9. Adicione o seguinte linha de código para o arquivo que inicia o ecrã:

sudo /home/pi/mztx-ext-2.4/src/mztx06a &

10. Salve e saia do arquivo. Em seguida, reiniciar o Raspberry Pi usando o seguinte comando:

$ Sudo reinicialização

Você pode remover seu monitor HDMI agora e começar a trabalhar com sua tela TFT LCD. Uma coisa que você terá
que manter em mente é que a resolução da tela é muito pequena e não é otimizado para codificação. Nós preferimos
usar o monitor HDMI para executar as principais modificações de código que são necessários na próxima seção. A
utilização do ecrã TFT LCD neste projeto é para acomodar as necessidades de mobilidade e portabilidade do
termostato.
Optimizar a GUI para o ecrã TFT LCD
A resolução da tela TFT LCD que configurado na seção anterior é de apenas 320 x 240 pixels, mas as janelas que
criamos na primeira fase de programação são bastante grandes. Portanto, antes de copiar e executar nosso
código Python no Raspberry Pi, precisamos ajustar alguns parâmetros no código.

Em seu computador regular, onde você tem pasta deste capítulo a partir do código-fonte do livro, abrir o Thermostat_Stage2.py
Arquivo. Este arquivo contém os detalhes da modificação necessária para obter o tamanho ideal com pequenas
alterações cosméticas. Você estará usando esse arquivo, em vez de um que usamos na etapa anterior, em seu
Raspberry Pi. Esses ajustes no código são explicadas nas seguintes linhas de código. A primeira grande alteração é
no nome da porta. Para o Raspberry Pi, você precisa alterar o nome da porta Arduino de que você estava usando no
primeiro estágio de / dev / ttyACM0,

que é o endereço atribuído a Arduino, na maioria dos casos:

porto = serial.Serial ( '/ dev / ttyACM0', 9600, tempo limite = 1)

Neste arquivo de programa, o tamanho do Tkinter janela principal ea matplotlib figura também são ajustados para se ajustar ao tamanho
da tela. Se você estiver usando uma tela de tamanho diferente, altere as seguintes linhas de código de forma adequada:

top.minsize (320,160)
pyplot.figure (figsize = (4,3))

Agora, com as alterações anteriores, a janela de GUI deve ser capaz de caber dentro da tela do Raspberry Pi. Como a
tela do Raspberry Pi será usado como a tela dedicado para a aplicação termostato, precisamos ajustar o tamanho do
texto na tela para ajustar a janela corretamente. Adicione o fonte = ( "Helvética", 20) texto na declaração dos rótulos para
aumentar o tamanho da fonte. A seguinte linha de código mostra mudanças que são executadas nos rótulos para conter
os nomes dos sensores:

Tkinter.Label (topo,
text = "Umidade",
fonte = ( "Helvética", 20)). grade (coluna = 1, linha = 2)

Da mesma forma, o Fonte opção é adicionada aos rótulos de observação:

HumdUnitLabel = Tkinter.Label (topo,

text = "%",
fonte = ( "Helvética", 20))

As etiquetas para a unidade de observação também carregam modificações semelhantes:

HumdLabel.config (text = cleanText (leitura [1]),

fonte = ( "Helvética", 20))

o Thermostat_ Stage2.py ficheiro já inclui as modificações anteriores e está pronto para ser executado em seu Raspberry Pi.
Antes de executar o arquivo, primeiro precisamos copiar o arquivo para o Raspberry Pi. Nesta fase, o hub USB será muito
útil para copiar os arquivos. Se você não tiver um hub USB, você pode utilizar duas portas USB disponíveis
simultaneamente para anexar
o pen drive USB, mouse e teclado. Com o uso do hub USB, conecte o pen drive USB contendo os arquivos
Python e copiá-los para a pasta base. Anexar a porta USB da placa Arduino para uma das extremidades do
cubo de USB. A partir do menu Iniciar do Raspberry Pi, abra o LXTerminal programa navegando até Acessórios
| LXterminal.
Executar o código Python a partir da pasta casa e você será capaz de ver a janela de interface de usuário otimizada que se
abre na tela do Raspberry Pi. Se cada passo mencionado no capítulo é realizado corretamente, você será capaz de ver a
observação do sensor que está sendo impresso quando você clica no Começar botão:

No final do capítulo, você deve estar se perguntando o que uma unidade móvel com sensores, Arduino, Raspberry Pi, e
ecrã TFT pode parecer. A seguir é apresentada uma imagem termostato amostra que foi desenvolvido utilizando as
instruções dadas neste capítulo. Foi usada uma chapa de acrílico para segurar o Raspberry Pi ea placa Arduino uniram
e criaram um formato compacto:
Solução de problemas
Existem alguns problemas conhecidos que você pode enfrentar nesta fase do projeto. A seção a seguir
descreve esses problemas e suas soluções rápidas:

O Raspberry Pi não está inicializando:

Certifique-se de que o cartão SD está formatado corretamente com as ferramentas especificadas. O

Raspberry Pi não inicializa se o cartão SD não está preparado corretamente. Verifique o cabo HDMI eo

monitor para ver se eles estão funcionando bem. Certifique-se de que o adaptador de energia é compatível

com o Raspberry Pi. A tela TFT LCD não liga:

Certifique-se de que a tela está devidamente conectado aos pinos GPIO do Raspberry Pi.

Se você estiver usando qualquer outra tela TFT LCD, certifique-se de sua folha de dados que sua tela
não requer energia adicional.
Verifique se a tela está configurado corretamente usando as etapas descritas no
Optimizar a GUI para o ecrã TFT LCD seção. Há uma taxa de atualização

lenta dos dados de sensores no Raspberry Pi:

Tente diminuir o atraso entre cada mensagem de série que é enviado pelo Arduino. Encerrar qualquer outro
aplicativo que está sendo executado em segundo plano.
resumo
Com este projecto, criado com sucesso um termostato portátil e destacável usando Arduino, que monitora a temperatura,
umidade e luz ambiente. Durante este processo, nós montada a unidade de sensor termostato usando os componentes
necessários e desenvolvido programa personalizado Arduino para apoiá-los. Nós também utilizou métodos de programação
Python, incluindo o desenvolvimento de GUI e parcelas usando Tkinter e matplotlib bibliotecas respectivamente. Mais tarde, no
capítulo, utilizamos o Raspberry Pi para converter um mero protótipo projeto em uma aplicação prática. Daí em diante, você
deve ser capaz de desenvolver projetos semelhantes que exigem que você observe e visualizar informações do sensor em
tempo real. Daqui para frente, estaremos expandindo esse projeto para acomodar futuros temas como Arduino networking,
comunicação em nuvem, e monitoramento remoto. No próximo nível do projeto termostato, que irá integrar esses recursos
avançados e torná-lo um projeto de DIY realmente engenhoso que pode ser usado na vida cotidiana. No próximo capítulo,
vamos começar a próxima fase da nossa jornada de fazer projetos simples Python-Arduino para projetos da Internet das
coisas conectados à Internet e remotamente acessíveis.
Capítulo 8. Introdução ao Arduino
Networking
Até agora, usamos uma conexão serial programado para interagir com Arduino, um monitor serial para observar os dados
de série Arduino, e uma biblioteca de série Python ( pyserial) para transferir dados entre as aplicações e Arduino Python.
Durante todo esse intercâmbio, a gama de comunicação foi limitado devido à conexão serial com fio. Como solução, você
pode usar um protocolo sem fio, como ZigBee, Bluetooth, ou outros canais de RF para estabelecer um canal de
comunicação para a interface serial remoto. Estes protocolos sem fio são amplamente utilizados em aplicações de
hardware remotos, e eles usam a interface serial para transferir dados. Devido ao seu uso de comunicação serial, esses
protocolos exigem pouca ou nenhuma alteração de programação adicionais no lado do Arduino ou Python. Você pode exigir
hardware adicional para permitir que esses protocolos, no entanto. A principal vantagem destes protocolos é que eles são
realmente fácil de implementar. No entanto, eles são restritas com apenas uma pequena área de cobertura geográfica e
largura de banda de dados limitada.

Além de métodos de comunicação serial, a outra maneira de acessar remotamente o dispositivo Arduino é a utilização de uma

rede de computadores. Hoje, as redes de computadores são a forma mais prolífico de comunicação entre as unidades de

computação. Nos próximos dois capítulos, vamos explorar várias técnicas de rede usando Arduino e Python, que vão desde o

estabelecimento de conectividade muito básico Ethernet para desenvolver complexos, aplicações web baseadas em nuvem.

Neste capítulo, vamos abordar os seguintes tópicos:

Os fundamentos de extensões de redes e hardware que permitem a rede para Arduino

estruturas Python usado para desenvolver Hypertext Transfer Protocol (HTTP) servidores web em seu
computador
Interface clientes HTTP baseado em Arduino com o protocolo de mensagens Python servidor web Internet das coisas MQTT

(vamos instalar uma ferramenta de middleware chamada mosquitto

para permitir MQTT em nosso computador)

Utilizando o paradigma publisher / assinante, usado por MQTT, para desenvolver aplicações web Arduino-
Python
Arduino e redes de computadores
redes de computadores é um grande domínio, e cobrindo todos os aspectos do trabalho em rede não é o principal objetivo deste
livro. Vamos, no entanto, tentar explicar alguns fundamentos de redes de computadores onde este conhecimento terá de ser
aplicada. Ao contrário da abordagem de interface em série, em que é necessária uma ligação ponto-a-ponto entre os dispositivos,
a abordagem à base de rede proporciona distribuído acesso aos recursos. Especificamente em aplicações de hardware onde
uma única unidade de hardware é necessário para ser acessado por vários pontos de extremidade (por exemplo, em um
computador pessoal, telefone celular, ou um servidor remoto), a rede de computadores está superior.

Nesta seção, vamos cobrir o básico de componentes de rede e hardware que permitem a rede no Arduino. Mais
adiante neste capítulo, vamos usar a biblioteca Arduino e um built-in exemplo para demonstrar como o acesso
remoto ao Arduino usando suas obras de rede local.
fundamentos de rede
Sempre que você vê um computador ou dispositivo móvel, você também está olhando para algum tipo de rede de computador que
está sendo usado para conectar esses dispositivos com outros dispositivos. Em termos simples, uma rede de computadores é um
grupo de dispositivos computacionais interligados (também chamados de nós de rede) que permitem a troca de dados entre esses
dispositivos. Estes nós da rede incluem vários dispositivos, como computadores pessoais, telefones celulares, servidores, tablets,
roteadores e outras peças de hardware de rede.

Uma rede de computadores podem ser classificados em vários tipos de acordo com parâmetros como localização
geográfica, topologia de rede e escopo organizacional. Em termos de escala geográfica, uma rede podem ser
categorizadas em rede de área local (LAN), rede de área local (HAN), rede de área alargada (WAN), e assim por diante.
Quando você está utilizando seu roteador doméstico para se conectar à Internet, você está usando a LAN criado pelo seu
roteador. Com relação à organização que lida com a rede, LAN podem ser configuradas como Intranet, Extranet e
Internet. A Internet é o maior exemplo de qualquer rede de computadores, uma vez que interliga todos os tipos de redes
implantadas globalmente. Em sua implementação de vários projectos ao longo deste livro, você vai ser maioritariamente
através do seu LAN e da Internet para a troca de dados entre um Arduino, o computador, o Raspberry Pi, e os serviços
em nuvem.

Para padronizar a comunicação entre os nós da rede, vários organismos e organizações de governo criaram um conjunto
de regras chamado protocolos. Na grande lista de protocolos padrão, existem alguns protocolos que o computador usa em
uma base diária. Os exemplos desses protocolos associados à rede de área local incluem Ethernet e Wi-Fi. Na família
IEEE 802 de padrões, o padrão IEEE 802.3 descreve diferentes tipos de conectividade com fios entre os nós de uma rede
de área local, também chamado de Ethernet. Da mesma forma, LAN sem fios (também referido como Wi-Fi), faz parte da
norma IEEE 802.11, em que um canal de comunicação utiliza bandas de frequência sem fios para a troca de dados. A
maioria dos nós de rede implantados com IEEE 802 padrões (isto é, Ethernet, Wi-Fi, e assim por diante) tem um
identificador único atribuído ao hardware de interface de rede, chamado de Controle de acesso de mídia (MAC) endereço.
Este endereço é atribuído pelo fabricante e é mais fixo para cada interface de rede. Enquanto estiver usando Arduino para
conectividade de rede, vamos precisar do endereço MAC para permitir rede. Um endereço MAC é um endereço de 48 bits,
e em forma amigável-humano que contém seis grupos de dois dígitos hexadecimais. Por exemplo, 01: 23: 45: 67: 89: AB é
a forma humana de leitura de um endereço MAC de 48 bits. Enquanto o endereço MAC é associado com o nível do
hardware (isto é, “físicos”) protocolos, a Protocolo de Internet (IP) é um protocolo de comunicação que é amplamente
utilizado no nível da Internet para permitir internetworking entre os nós de rede. Na implementação da versão 4 do conjunto
de protocolos IP (IPv4), cada nó da rede é atribuído um número de 32 bits chamado Endereço de IP ( por exemplo,
192.168.0.1). Quando você conectar um computador, telefone ou qualquer outro dispositivo à sua rede doméstica local, um
endereço IP é atribuído a esse dispositivo pelo seu roteador. Um dos mais endereços IP populares é 127.0.0.1, que
também é chamado de localhost Endereço de IP. Além do endereço IP atribuído a um
computador pela rede, cada computador tem também o endereço IP localhost associado a ele. O endereço IP localhost
é muito útil quando você deseja acessar internamente ou ligue o seu computador a partir do mesmo dispositivo. No
caso de um aplicativo de acesso remoto, você precisa saber o endereço IP atribuído pela rede.
Obtendo o endereço IP do seu computador
Arduino é um dispositivo de recursos limitados, e, portanto, só pode demonstrar uma quantidade limitada de capacidade de
rede. Ao trabalhar com projetos baseados em Arduino, que incluem a utilização de uma rede de computadores, você precisará
de um servidor ou interface Gateway. Essas interfaces incluem, mas não estão limitados a, um computador desktop, um laptop,
o Raspberry Pi, e outras instâncias de computação remota. Se você estiver usando estas interfaces como parte de seu projeto
de hardware, você precisará de seus endereços IP. Certifique-se que eles estão sob a mesma rede que o seu Arduino. A
seguir estão as técnicas para obter endereços IP nos principais sistemas operacionais.

janelas
Na maioria das versões do sistema operacional Windows, você pode obter o endereço IP do Conexão de rede utilidade em Painel
de controle. Navegar para Painel de Controle | Rede e Internet
| Conexões de rede e abra a Local Area Connection Status janela. Clique no detalhes botão para ver os
detalhes do Detalhes da conexão de rede janela. Como você pode ver nesta imagem, o endereço de IP da
interface de rede é listada como Endereço IPv4 na janela aberta:

Você também pode obter o endereço IP do seu computador usando o built-in ipconfig Utilitário. Abra o prompt
de comando e digite o comando a seguir:

> ipconfig

Como você pode ver na imagem seguinte, o endereço IP do seu computador é listado sob o adaptador Ethernet. Se
você estiver usando uma conexão sem fio para se conectar à sua rede,
o adaptador Ethernet será substituído pelo adaptador Ethernet sem fio.

Mac OS X
Se você estiver usando Mac OS X, você pode obter o endereço IP a partir das definições de rede. Aberto
Preferências do Sistema e clique no Rede ícone. Você verá uma janela semelhante ao que é mostrado na imagem a
seguir. Na barra lateral esquerda, clique na interface que você está procurando para obter o endereço IP de.
Se você quiser obter o endereço IP usando o terminal, você pode usar o comando a seguir. Este comando irá
exigir que você digite o nome do sistema da interface, en0:

$ Ipconfig getifaddr en0

Se você estiver conectado a várias redes e não estão cientes do nome da rede, você pode encontrar a lista de
endereços IP associados com o computador, usando o comando mostrado aqui:

$ Ifconfig | grep inet

Como você pode ver nesta imagem, você vai ter todos os endereços de rede associados com o seu computador
Mac e outros parâmetros de rede:

Linux
No Ubuntu OS, você pode obter o endereço IP do seu computador a partir do Configurações de rede Utilitário. Para abri-la,
navegar para Configurações do Sistema | Rede e clique no adaptador através do qual o computador está conectado à sua
rede doméstica. Você pode selecionar um adaptador apropriado para obter o endereço IP, como mostrado na imagem
seguinte:
Em um sistema baseado em Linux, existem várias maneiras de obter o endereço IP a partir da linha de comando.
Você pode usar o mesmo comando ( ifconfig) que usamos no Mac OS X no ambiente Linux para obter o endereço IP
do seu computador:

$ ifconfig

Você pode obter o endereço IP do inet addr campo do adaptador apropriado, como mostrado neste
screenshot:

Se for suportado pelo seu sistema operacional, outro comando que pode ser utilizado para obter o endereço IP é nome de
anfitrião:

$ Hostname -I

Tenha cuidado ao usar esta utilidade para obter o endereço IP, como você pode acabar recebendo o endereço IP de um
adaptador diferente se você não estiver familiarizado com as opções de comando suportados do utilitário.

Nota

Se você estiver indo para conectar o Arduino à mesma rede local que o seu computador, certifique-se que você está
escolhendo o endereço IP apropriado que é coberta pelo mesmo domínio como o do seu computador. Também garantir que
nenhum outro dispositivo de rede está usando o mesmo endereço IP que você selecionou para o seu Arduino. Esta prática
ajudará a evitar conflitos de endereços IP dentro da rede.
Networking extensões para o Arduino
Existem vários dispositivos de hardware disponíveis na comunidade Arduino que Ative a rede para a
plataforma Arduino. Entre esses dispositivos, alguns podem ser utilizados como extensões para sua placa
Arduino existente, enquanto outros existir como autônomo Arduino módulos com capacidades de rede.
Maioria das extensões populares usados ​para habilitar a rede são o Arduino Ethernet Shield e Arduino
Escudo WiFi. Da mesma forma, Arduino Yun é um exemplo de uma plataforma Arduino autônomo que inclui
recursos internos de rede. Neste livro, vamos desenvolver várias aplicações de redes em todo o Arduino
Ethernet Shield. Há também algumas outras extensões (Arduino GSM blindagem) e autônomo Arduino
plataformas (Arduino Ethernet, Arduino Tre, e assim por diante), mas nós não estamos indo para cobri-los em
detalhe.

Arduino Ethernet Shield

O Arduino Ethernet Shield é uma extensão de rede de origem oficialmente suportado e aberto projetado para trabalhar
com Arduino Uno. The Shield Ethernet é equipado com um conector RJ45 para permitir rede Ethernet. The Shield
Ethernet é projetado para montar em cima do Arduino Uno e estende-se a disposição dos pinos do seu Arduino Uno ao
topo da placa. The Shield Ethernet também é equipado com um slot para cartão microSD para armazenar arquivos
importantes através da rede. Assim como a maioria dessas extensões escudo, o escudo Ethernet é alimentado pela
placa Arduino que é anexado a.

Fonte: http://arduino.cc/en/uploads/Main/ArduinoEthernetShield_R3_Front.jpg

Cada placa Ethernet Shield é equipado com um endereço de hardware único (MAC). Você pode vê-lo na parte de trás da
placa. Você pode querer anotar este endereço hardware, como ele vai ser exigido com frequência nos próximos exercícios.
Também certifique-se de que você se familiarizar com a montagem do Arduino Ethernet Shield para os exercícios. Comprar
um Arduino
módulo Ethernet Shield de SparkFun ou Amazon antes do seu trabalho início em todos os exercícios. Você
pode obter informações adicionais sobre este Escudo
http://arduino.cc/en/Main/ArduinoEthernetShield .

Escudo WiFi Arduino

O WiFi Escudo Arduino tem um layout similar ao do Arduino Ethernet Shield, tanto quanto de montagem na parte
superior da placa Arduino está em causa. Em vez do conector Ethernet RJ45, o Escudo WiFi contém
componentes para habilitar a rede sem fio. Usando o Escudo Wi-Fi, você pode conectar-se ao IEEE 802.11
(Wi-Fi) redes sem fio, que é uma das formas mais populares de conexão de computadores à rede doméstica
hoje.

Fonte: http://arduino.cc/en/uploads/Main/A000058_front.jpg

O WiFi Escudo Arduino requer energia adicional através de um conector USB. Ele também contém um slot microSD para
salvar arquivos. Assim como o protetor de Ethernet, é possível visualizar o endereço MAC na parte de trás da placa. Mais
informações sobre o WiFi Escudo Arduino pode ser encontrada em http://arduino.cc/en/Main/ArduinoWi-FiShield .

Arduino Yun
Ao contrário do escudo Ethernet eo Escudo WiFi, o Arduino Yun é uma variante independente da placa Arduino. Ele inclui
tanto Ethernet e conectividade de rede baseado em Wi-Fi, além do básico Arduino componente-o microcontrolador. Yun
está equipado com as mais recentes e mais poderosas unidades de processamento em comparação com Uno. Em vez da
maneira tradicional de usar Arduino código, Yun suporta uma versão leve do sistema operacional Linux, fornecendo
funcionalidade semelhante a um computador de placa única, como o Raspberry Pi. Você pode usar seu Arduino IDE para
o programa Yun, mesmo durante a execução de scripts Unix shell.
 Fonte: http://arduino.cc/en/uploads/Main/ArduinoYunFront_2.jpg

Você pode encontrar mais informações sobre Yun no site do Arduino oficial, em
http://arduino.cc/en/Main/ArduinoBoardYun .
biblioteca Arduino Ethernet
A biblioteca Arduino Ethernet fornece suporte para o protocolo Ethernet, e, portanto, proporciona suporte para
extensões Ethernet de Arduino, tal como a Ethernet Shield. Esta é uma biblioteca Arduino padrão e que é
distribuído com o Arduino IDE.

A biblioteca é projetado para aceitar pedidos de ligação quando implantado como um servidor e ao fazer conexões de
saída para outros servidores quando está a ser utilizado como um cliente. A biblioteca simultaneamente suporta até quatro
conexões devido à capacidade de computação limitada da placa Arduino. Para usar a biblioteca Ethernet em seu programa
Arduino, o primeiro passo que você tem que tomar é para importá-lo para o seu esboço Arduino:

# incluem <Ethernet.h>

Os implementos biblioteca Ethernet várias funcionalidades através de aulas específicas, que são descritos como segue.

Gorjeta

Nós vamos apenas descrever os métodos importantes fornecidos por essas classes. Você pode obter mais
informações sobre esta biblioteca e suas classes de
http://arduino.cc/en/Reference/Ethernet .

A classe Ethernet
o Ethernet classe é uma classe principal da biblioteca Ethernet e fornece métodos para inicializar esta biblioteca e as
configurações de rede. Esta é uma classe essencial para qualquer programa que quer usar a biblioteca Ethernet para
estabelecer conexões através do Escudo Ethernet. A informação primária necessária para estabelecer esta conexão é o
endereço MAC do dispositivo. Você precisa criar uma variável que tem o endereço MAC como uma matriz de 6 bytes,
conforme descrito aqui:

byte mac [] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

A biblioteca Ethernet suporta a Protocolo de Controlo de DHCP (Dynamic Host), que é responsável por
atribuir dinamicamente endereços IP a novos nós de rede. Se sua rede doméstica está configurado para DHCP
suporte, você pode estabelecer a conexão Ethernet usando o begin (mac) método do Ethernet classe:

Ethernet.begin (MAC);

Tenha em mente que quando você está inicializando uma conexão Ethernet usando esta classe, você só está
inicializando a conexão Ethernet e configurar o endereço IP. Isso significa que você ainda precisa configurar Arduino
como um servidor ou um cliente, a fim de permitir a comunicação.

A classe IPAddress

Em aplicações onde você tem que atribuir manualmente o endereço IP para o seu dispositivo Arduino, você terá que
usar o Endereço de IP classe da biblioteca Ethernet. Essa classe fornece métodos para especificar o endereço IP, que
pode ser local ou remoto, dependendo do
inscrição:

IPAddress ip (192,168,1,177);

O endereço IP criados usando este método pode ser usado na inicialização da conexão de rede que foi
realizada na seção anterior. Se você quiser atribuir um endereço IP manual para o Arduino, você pode
usar o begin (mac, ip) método com os endereços MAC e IP:

Ethernet.begin (mac, ip);

A classe de servidor

o Servidor classe foi projetada para criar um servidor usando a biblioteca Ethernet em Arduino, que escuta as solicitações
de conexão de entrada para uma porta específica. o EthernetServer ()
método, quando especificado com no valor inteiro do número da porta, inicializa o servidor no Arduino:

EthernetServer servidor = EthernetServer (80);

Por porta especificando 80 na linha de código anterior (que representa o protocolo HTTP na suíte TCP / IP),
criamos especificamente um servidor web usando a biblioteca Ethernet. Para começar a ouvir os pedidos
de ligação, você tem que usar o início() método no servidor objeto:

server.begin ();

Uma vez que a conexão é estabelecida, você pode responder a um pedido usando vários métodos suportados
pela classe servidor, como write (), imprimir (), e println ().

A classe Cliente

o Cliente classe fornece métodos para criar um cliente Ethernet para conectar e se comunicar com os servidores. o EthernetCli
() método inicializa um cliente que pode ser conectado a um servidor específico usando seu endereço IP eo
número da porta. o connect (ip, porta) método no cliente objeto irá estabelecer uma conexão com o servidor no
endereço IP mencionado:

cliente EthernetClient; client.connect (servidor,

80);

o Cliente classe também tem a conectado() método, que fornece o status da conexão atual em binário. Esse
status pode ser verdade ( ligado) ou false ( desconectado). Este método é útil para a monitorização periódica
do estado da ligação:

client.connected ()

Outros métodos de clientes importantes incluem ler() e escrever(). Estes métodos ajudam o cliente Ethernet para ler o
pedido do servidor e para enviar mensagens para o servidor, respectivamente.
Exercício 1 - um servidor web, o seu primeiro programa de rede
Arduino
A melhor maneira de testar a biblioteca Arduino Ethernet e Ethernet Shield é usando os exemplos embutidos que são
implantados com o Arduino IDE. Se você estiver usando a versão 1.x do Arduino IDE, você pode encontrar um monte de
exemplos Ethernet navegando até arquivo | Exemplos | Ethernet. Ao utilizar um destes exemplos, vamos construir um
servidor web que fornece os valores do sensor quando solicitado por um navegador web. Como Arduino será conectado
à sua rede doméstica através da Ethernet, você será capaz de acessá-lo a partir de qualquer outro computador
conectado à rede. As principais metas para este exercício estão listadas aqui:

Use a biblioteca Arduino Ethernet com a extensão Ethernet Shield Arduino para criar um servidor web

Acessar remotamente Arduino usando sua rede de computadores em casa

Utilizar um exemplo Arduino padrão para fornecer valores do sensor de umidade e de movimento utilizando um servidor web

Para atingir esses objetivos, o exercício está dividido nas seguintes etapas:

Projetar e hardware de construção para o exercício usando o Arduino eo escudo Ethernet

Executar um exemplo padrão do Arduino IDE como o ponto de partida do exercício Modificar o exemplo para
acomodar o seu design de hardware e reimplantar o código a seguir é um diagrama Fritzing do circuito necessário para
este exercício. A primeira coisa que você deve fazer é montar o escudo Ethernet em cima do seu Arduino Uno.
Certifique-se que todos os pinos do Escudo Ethernet estão alinhados com os pinos correspondentes do Arduino Uno.
Então você precisa para ligar o sensor usado anteriormente umidade, HIH-4030, eo sensor de movimentos PIR.
Nota

Enquanto a implementação do hardware Arduino para conectividade remota sem USB, você terá que fornecer alimentação
externa para a placa, como você já não tem uma conexão USB para alimentação da placa.

Agora, conecte o Arduino Uno para um computador através de um cabo USB. Você também vai precisar para conectar
Arduino à sua rede doméstica local usando um cabo Ethernet. Para fazer isso, use um CAT5 direto ou cabo CAT6 e
conexão final um do cabo ao seu roteador doméstico. Este router deve ser o mesmo dispositivo que fornece acesso à
rede para o computador que você está usando. Ligue a outra extremidade do cabo Ethernet para a porta Ethernet da
placa Arduino Ethernet Shield. Se a conexão de nível físico foi estabelecida corretamente, você deve ver uma luz verde
no porto.

Agora é hora de começar a programar o seu primeiro exemplo Ethernet. Abra o Servidor web exemplo por navegar para arquivo
| Exemplos | Ethernet | Servidor web em sua Arduino IDE. Como você pode ver, a biblioteca Ethernet está incluído com as
outras bibliotecas necessárias eo código suportado. No código, você precisará alterar os endereços MAC e IP para fazer o
trabalho para a sua configuração. Enquanto você pode obter o endereço MAC do Escudo Ethernet da parte de trás da placa,
você terá que selecionar um endereço IP de acordo com a sua configuração de rede doméstica. Como você já obteve o
endereço IP do computador que você está trabalhando, selecionar outro endereço no intervalo. Certifique-se de que nenhum
outro nó da rede está usando esse endereço IP. Use esses endereços MAC e IP para atualizar os seguintes valores em
seu código. Você terá de repetir estes passos para cada exercício, quando você está lidando com Arduino
Ethernet:

byte mac [] = {0x90, 0xA2, 0xDA, 0x0D, 0x3F, 0x62}; IPAddress ip (10,0,0,75);

Gorjeta

Na rede IP, a gama visível de endereços IP para sua rede é uma função de outro endereço de chamada sub-rede ou
sub-rede. A sub-rede de sua rede LAN IP pode ajudá-lo a selecionar o endereço IP apropriado para o Escudo
Ethernet na faixa do endereço IP do seu computador. Você pode aprender sobre os conceitos básicos da sub-rede
no
http://en.wikipedia.org/wiki/Subnetwork .

Antes de se aventurar ainda mais para o código, compilar o código com estas modificações e enviá-lo para o seu
Arduino. Uma vez que o processo de upload é concluída com êxito, abra um navegador e digite o endereço IP que
você tinha especificado no esboço Arduino. Se tudo correr bem, você deve ver texto exibindo os valores dos pinos
analógicos. Para entender melhor o que aconteceu aqui, vamos voltar para o código. Como você pode ver, no início
do código que inicializar a biblioteca servidor Ethernet na porta 80 usando o

EthernetServer método da biblioteca Ethernet:

servidor EthernetServer (80);

Durante a execução do configuração(), o programa inicializa a conexão Ethernet através do Escudo Ethernet usando o Ethernet.bein
() método com o Mac e ip variáveis ​que você definiu anteriormente. o server.begin () método irá iniciar o servidor a partir
daqui. Ambos os passos são obrigatórios para iniciar um servidor se você estiver usando a biblioteca Ethernet para
código de servidor:

Ethernet.begin (mac, ip); server.begin ();

No ciclo() função, inicializar um cliente opor-se a ouvir as solicitações de entrada do cliente usando o EthernetClient método.
Este objeto irá responder a qualquer pedido proveniente de clientes conectados que tentam acessar o
servidor Ethernet através da porta 80: cliente EthernetClient = server.available ();

Ao receber o pedido, o programa irá aguardar o pedido de carga ao fim. Em seguida, ele irá responder ao cliente
com dados HTML formatado usando o client.print () método:

enquanto (client.connected ()) {

if (client.available ()) {
char c = client.read (); Serial.write (c);

# Código de resposta
}

Se você tentar acessar o servidor Arduino a partir do navegador, você verá que o servidor web respostas aos clientes
com as leituras pino analógico. Agora, para obter os valores adequados de umidade e sensores PIR que nós
conectados no design de hardware, você terá que
executar a seguinte modificação do código. Você vai notar aqui que está a responder aos clientes com os valores calculados
de umidade relativa do ar, em vez de leituras brutos de todos os pinos analógicos. Nós também ter modificado o texto que
será impresso no navegador da web para coincidir com o título de sensor adequada:

if (c == '\ n' && currentLineIsBlank) {

// enviar um client.println padrão cabeçalho de resposta HTTP ( "HTTP /
1.1 200 OK"); client.println ( "Content-Type: text / html"); client.println (
"Connection: close"); client.println ( "Refresh: 5"); client.println ();

client.println ( "<DOCTYPE HTML!>"); client.println (

"<html>");
flutuar sensorReading = getHumidity (analogChannel, temperatura); client.print ( "Humidade Relativa de
HIH4030 é"); client.print (sensorReading); client.println ( "% <br />"); client.println ( "</ html>"); pausa; }

Neste processo, nós também acrescentou uma função de Arduino, getHumidity (), que vai calcular a humidade relativa a partir
dos valores observados com os pinos da analógicos. Nós já usamos uma função semelhante para calcular a umidade
relativa em um dos projetos anteriores:

flutuar getHumidity (int analogChannel, temperatura flutuador) {

flutuar supplyVolt = 5,0;
int HIH4030_Value = analogRead (analogChannel); flutuar analogReading = HIH4030_Value / 1023,0 * supplyVolt; flutuar
sensorReading = 161,0 * analogReading / supplyVolt - 25,8; flutuar humidityReading = sensorReading / (1,0546-0,0026
temperatura *); voltar humidityReading; }

Você pode implementar essas alterações para o Servidor web Arduino exemplo para a fase de teste, ou a apenas
aberto WebServer_Custom.ino esboçar a partir da Exercício 1 - Web Server pasta do seu diretório de código. Como você pode ver
no arquivo esboço aberto, já modificou o código para refletir as mudanças, mas você ainda vai ter que mudar os
endereços MAC e IP para os endereços apropriados. Uma vez que você é feito com essas pequenas mudanças,
compilar e fazer o upload do esboço para Arduino.

Se tudo correr como planejado, você deve ser capaz de acessar o servidor web usando o seu navegador web. Abra o
endereço IP do seu Arduino recentemente preparado no navegador da web. Você deve ser capaz de receber uma resposta
semelhante à exibida na imagem seguinte. Apesar de estarmos apenas exibindo valores de umidade através deste esboço,
você pode facilmente anexar valores do sensor de movimento utilizando adicional client.print () métodos.
Assim como o mecanismo foi implementado neste exercício, um servidor Web responde ao pedido feito por um navegador web e
fornece as páginas da web que você está procurando. Embora este método é muito popular e universalmente usada para fornecer
páginas da web, a carga útil contém uma grande quantidade de metadados adicionais em comparação com o tamanho real das
informações do sensor. Além disso, a implementação do servidor usando a biblioteca servidor Ethernet ocupa uma grande
quantidade de recursos do Arduino. Arduino, sendo um dispositivo de recursos limitados, não é adequado para executar um
aplicativo de servidor, como recursos do Arduino devem ser priorizados para lidar com os sensores ao invés de comunicação. Além
disso, o servidor web criado usando a biblioteca Ethernet suporta uma quantidade muito limitada de conexões de cada vez,
tornando-o inutilizável para aplicações em larga escala e sistemas multi-utilizador.

A melhor abordagem para superar esse problema é usando Arduino como um dispositivo cliente, ou usando protocolos de
comunicação leves que são projetados para trabalhar com dispositivos de hardware constrangimentos de recursos. Nas
próximas seções, você está indo para aprender e implementar essas abordagens para a comunicação Arduino na Ethernet.
Desenvolvimento de aplicações web usando Python
Ao implementar o programa anterior, você tiver habilitado rede em Arduino. No exemplo anterior, criamos um servidor web
HTTP utilizando métodos disponíveis a partir da biblioteca Ethernet. Ao criar um servidor web Arduino, fizemos os
recursos Arduino disponível na rede. Da mesma forma, Python também oferece extensibilidade por meio de várias
bibliotecas para criar interfaces de servidor web. Ao executar o servidor web baseado em Python no seu computador ou
outros dispositivos, como o Raspberry Pi, você pode evitar o uso Arduino para hospedar o servidor web. aplicações web
criado utilizando linguagens de alto nível como Python também pode fornecer recursos adicionais e extensibilidade em
comparação com Arduino. Nesta seção, vamos utilizar a biblioteca Python, web.py, criar um servidor web Python. Também
vamos usar esta biblioteca para criar aplicações web interativas que permitirão a transferência de dados entre um cliente
Arduino e um navegador web. Depois de ter aprendido as noções básicas de

web.py, que servirá de interface Arduino com web.py usando portas seriais para fazer Arduino acessível através do
servidor web Python. Então, vamos atualizar o método de comunicação Arduino a partir da interface serial para
mensagens com base em HTTP.
framework web Python - web.py
Um servidor web pode ser desenvolvida em Python usando vários frameworks web, como Django, garrafa, Pilone, e web.py. Nós
selecionamos web.py como o framework web preferido devido à sua funcionalidades poderosas simples ainda. o web.py biblioteca
foi inicialmente desenvolvido pelo falecido Aaron Swartz, com o objetivo de desenvolver uma abordagem fácil e
simples para criar aplicações web usando Python. Esta biblioteca fornece dois métodos principais, OBTER e POSTAR, para
apoiar o HTTP

Transferência de Estado Representação (REST) arquitetura. Esta arquitetura é projetada para suportar o protocolo HTTP
através do envio e recebimento de dados entre clientes e servidor. Hoje, a arquitetura REST está implementado por um
grande número de sites para transferir dados através de HTTP.

Instalando web.py

Para começar com o web.py, você precisa instalar o web.py biblioteca usando Setuptools. Nós instalamos
Setuptools para vários sistemas operacionais em Capítulo 1 , Introdução ao Python e Arduino. No Linux e Mac
OS X, execute um destes comandos no terminal para instalar web.py:

$ Sudo easy_install web.py $ sudo pip

instalar web.py

No Windows, abra o Prompt de comando e execute o seguinte comando:

> easy_install.exe web.py

Se Setuptools está configurado corretamente, você deve ser capaz de instalar a biblioteca sem qualquer
dificuldade. Para verificar a instalação da biblioteca, abra o Python prompt interativo e executar este comando para
ver se você importou a biblioteca sem erros:

> > > importação web

Sua primeira aplicação web Python

A implementação de um servidor web usando web.py É um processo muito simples e direta. o web.py biblioteca requer a
declaração de um método obrigatório, OBTER, para iniciar com êxito o servidor web. Quando um cliente tenta acessar o servidor
usando um navegador web ou outro cliente, web.py recebe um OBTER dados de solicitação e retorna, conforme especificado pelo
método. Para criar um aplicativo web simples usando o web.py biblioteca, criar um arquivo de Python usando as seguintes linhas
de código e executar o arquivo usando Python. Você também pode executar o

webPyBasicExample.py arquivo da pasta de código deste capítulo:

URLs importação
web (=
'/', 'Índice'
)
índice de classe:
def GET (self):
retornar "Olá, mundo!" se __name__ ==
"__main__":
 app = web.application (URLs, globais ()) app.run ()

Em execução, você verá que o servidor está agora em execução e acessível através do
http://0.0.0.0:8080 endereço. Como o programa de servidor está em execução no 0.0.0.0 endereço IP, você pode acessá-lo
usando o mesmo computador, localhost, ou qualquer outro computador da mesma rede.

Para verificar o servidor, abra um navegador web e vá para http://0.0.0.0:8080. Quando você está tentando acessar o servidor a
partir do mesmo computador, você também pode usar
http://127.0.0.1:8080 ou http: // localhost: 8080. o 127.0.0.1 endereço IP está realmente para localhost, isto é, o endereço
de rede do mesmo computador no qual o programa está sendo executado. Você será capaz de ver a
resposta do servidor exibido no navegador, como mostrado na imagem seguinte:

Para entender como esse simples código funciona, confira o OBTER método no fragmento de código anterior.
Como você pode ver, quando o navegador solicita a URL, o OBTER método retorna o Olá Mundo! string para o
browser. Enquanto isso, você também pode observar dois outros obrigatório web.py componentes em seu
código: o urls e web.application () métodos. o web.py biblioteca requer inicialização do local de resposta na declaração
do
urls variável. Cada web.py- aplicativo baseado na web requer a aplicação (urls, global ()) método a ser
chamado para inicializar o servidor web. Por padrão, o web.py
aplicações executados em número da porta 8080, que pode ser alterado para outro número da porta, indicando que durante
a execução. Por exemplo, se você deseja executar o seu web.py aplicação na porta 8888, execute o seguinte comando:

$ Python webPyBasicExample.py 8888

Embora este só retorna de texto simples, você já criou com sucesso a sua primeira aplicação web usando Python. Vamos
levá-la para a frente a partir daqui e criar aplicações web mais complexas nos próximos capítulos utilizando o web.py biblioteca.
Para desenvolver estas aplicações complexas, que vai exigir mais do que apenas o OBTER método. Vamos começar
explorando conceitos de avanço para melhorar ainda mais a sua familiaridade com o web.py biblioteca.
conceitos web.py essenciais para o desenvolvimento de aplicações web

complexas
o web.py biblioteca foi projetada para fornecer métodos simples e conveniente para o desenvolvimento de sites dinâmicos e
aplicações web utilizando Python. utilização web.py, é realmente fácil de construir sites complexos, utilizando apenas alguns
conceitos adicionais Python junto com o que você já sabe. Devido a esta curva de aprendizagem limitada e fácil de
implementar métodos, web.py é uma das formas mais rápidas para criar aplicações web em qualquer linguagem de
programação. Vamos começar com a compreensão destes web.py conceitos em detalhe.

manipulação de URLs

Você deve ter notado que no nosso primeiro web.py programa, definimos uma variável chamada
urls que aponta para o local raiz (/) do Índice classe:

URLs = (
'/', 'Índice'
)

Na declaração anterior, a primeira parte, '/', é uma expressão regular usada para corresponder às solicitações de URL
reais. Você pode usar expressões regulares para lidar com consultas complexas que chegam ao seu web.py servidor e
ponto-los para a classe apropriada. Dentro web.py, você pode associar diferentes locais da página de destino com classes
apropriadas. Por exemplo, se você deseja redirecionar o / dados local para o dados classe, além do Índice classe, você pode
mudar o urls variável como se segue:

URLs = (
'/', 'Índice de', '/ dados',
'dados',
)

Com esta disposição, quando um cliente envia uma solicitação para o acesso http: // <ipaddress>: 8080 / dados endereço, o
pedido será dirigido para o dados classe e, em seguida, a OBTER ou POSTAR método de essa classe.

Os métodos GET e POST

No exercício 1, onde criamos um servidor web baseado em Arduino em execução na porta 80, foi utilizado um navegador web
para acessar o servidor web. Os navegadores da Web são um dos mais populares tipos de clientes web usados ​para
acessar um servidor web; cURL, Wget e crawlers são os outros tipos. Um navegador da Web usa HTTP para se comunicar
com qualquer servidor web, incluindo o servidor web Arduino que usamos. OBTER e POSTAR dois métodos fundamentais
suportados pelo protocolo HTTP para solicitações do servidor de endereços provenientes de um navegador web. Sempre
que você está tentando abrir um site no seu navegador ou qualquer outro cliente HTTP, na verdade você está solicitando a OBTER
função do servidor web; por exemplo, quando você abre um URL do site, http://www.example.com/, você está solicitando que o
servidor web que hospeda o site serve-lhe o OBTER pedido para a localização '/'. No manipulação de URLs

seção, você aprendeu a associar o web.py classes com locais de desembarque URL.
usando o OBTER método fornecido pela web.py biblioteca, você pode associar o OBTER solicitar com aulas individuais.
Depois de ter capturado o OBTER pedido, você precisa de retornar valores apropriados como a resposta para o cliente.
mostra o código seguinte trecho como o
OBTER() função será chamada quando alguém faz uma OBTER pedido para o local '/':

def GET (self):

f = self.submit_form ()
f.validates () T = 75

regresso render.test (F, t);

o POSTAR função do protocolo HTTP é usado principalmente para enviar um formulário ou qualquer outro dados para o servidor web.
Na maioria dos casos, POSTAR é incorporado em uma página da web, e um pedido para o servidor é gerado quando um usuário envia
o componente levando o POSTAR função. o
web.py biblioteca também oferece a POSTAR() função, que é chamado quando um tentativas do cliente web para entrar em contato com o web.py

servidor usando o POSTAR método. Na maioria das implementações do

POSTAR() função, o pedido inclui algum tipo de dados apresentados por meio de formulários. Você pode recuperar
elementos de formulário individuais usando f [ 'Celsius']. valor que lhe dará um valor associado com o elemento formulário
chamado Celsius. Uma vez o POSTAR() função tem realizado acções previstas, você pode retornar informações apropriadas
para o cliente em resposta à POSTAR solicitação:

def POST (self):

f = self.submit_form ()
f.validates ()
valor c = f [ 'Celsius']. t = c * (9,0 / 5,0) +
32 de retorno render.test (F, T)

Modelos
Agora você sabe como redirecionar uma solicitação HTTP para um URL apropriado, e também como implementar métodos
para responder a essas solicitações HTTP (ou seja, OBTER e POSTAR). Mas o que sobre a página web que precisa ser
processado uma vez que o pedido é recebido? Para entender o processo de renderização, vamos começar com a criação
de uma pasta chamada modelos no mesmo diretório onde o nosso web.py programa vai ser colocado. Esta pasta irá armazenar
os modelos que serão utilizados para tornar as páginas da web quando solicitado. Você tem que especificar a localização
desta pasta modelo no programa usando o template.render () função, como apresentado na seguinte linha de código:

render = web.template.render ( 'modelos')

Depois de ter instanciado a pasta de renderização, é hora de criar arquivos de modelo para o seu programa. De acordo com
os requisitos do seu programa, você pode criar tantos arquivos de modelo que você deseja. A linguagem chamada Templetor
é usado para criar esses arquivos de modelo em web.py. Você pode aprender mais sobre ele em http://webpy.org/templetor .
Cada arquivo de modelo criado usando Templetor precisa ser armazenado no formato HTML com o. html

extensão.

Vamos criar um arquivo chamado test.html no modelos pasta usando um editor de texto e cole
o seguinte trecho de código para o arquivo:

$ Def com (forma, i) <form method

= "POST">
$: Form.render () </ form>

<P> O valor é: $: i </ p>

Como você pode ver no trecho de código anterior, o arquivo de modelo começa com o $ def com () expressão, onde você precisa
especificar os argumentos de entrada como variáveis ​dentro dos colchetes. Uma vez que o modelo é processado, estas serão
as únicas variáveis ​que você pode utilizar para a página web; por exemplo, no trecho de código anterior, passamos duas
variáveis ​( Formato
e Eu) como variáveis ​de entrada. Utilizamos o Formato objeto usando $: form.render () para torná-lo dentro da página web. Quando
você precisa para tornar a Formato objeto, você pode passar diretamente a outra variável, simplesmente declarando-o (ou seja,
$: Eu). Templetor irá processar o código HTML do arquivo de modelo como ela é, enquanto utilizando as variáveis ​nos casos
em que eles estão sendo usados.

Agora você tem um arquivo de modelo, test.html, pronto para ser usado em seu web.py programa. sempre que um OBTER() ou POSTAR() função
é executada, você é obrigado a devolver um valor para o cliente solicitante. Embora você pode retornar qualquer variável para
essas solicitações, incluindo Nenhum,
você terá de prestar um arquivo de modelo onde a resposta está associada com o carregamento de uma página web. Você pode
retornar o arquivo de modelo usando o render () função, seguido pelo nome do arquivo dos argumentos de arquivo modelo e de entrada:

regresso render.test (f, i);

Como você pode ver na linha de código anterior, estamos voltando a prestados test.html
página, especificando o render.test () função, onde teste() é apenas o nome do arquivo sem a. html extensão. A função
também inclui um objecto de forma, f, e variável, Eu, que será passado como argumentos de entrada.

formas

o web.py biblioteca fornece maneiras simples de criar elementos de formulário usando o Formato
módulo. Este módulo inclui a capacidade de criar elementos de formulário HTML, obter entradas dos usuários, e validar
essas entradas antes de utilizá-las no programa Python. No seguinte trecho de código, estamos criando dois elementos
de formulário, Caixa de texto e Botão, usando o
Formato biblioteca:

submit_form = form.Form (
form.Textbox ( 'Celsius', description = 'Celsius'), form.button ( 'enviar', type = "submit", description =
'enviar')
)

além de Caixa de texto ( que obtém a entrada de texto dos usuários) e button ( que enviará o formulário), o Formato módulo também
fornece alguns outros elementos de forma, tal como Senha para obter a entrada de texto oculto, Dropbox para obter uma entrada
mutuamente exclusivas de uma lista drop-down, Rádio obter entradas mutuamente exclusivas de várias opções, e Caixa de seleção para
selecionar uma entrada binária das opções dadas. Apesar de todos esses elementos são muito fáceis de implementar, você
deve selecionar elementos de formulário apenas de acordo com o seu programa
requisitos. No web.py implementação de Formato, a página da web precisa para executar o POSTAR método cada vez que o

formulário é enviado. Como você pode nos ver na sequência da implementação do formulário no arquivo de modelo,

estamos declarando explicitamente o método formulário de inscrição como POST: $ def com (forma, i) <form method = "POST">

$: Form.render () </ form>

Exercício 2 - jogo com conceitos web.py usando a interface
serial Arduino
Agora você tem uma idéia geral do básico web.py conceitos utilizados para construir uma aplicação web. Neste exercício,
vamos utilizar os conceitos que você aprendeu para criar um aplicativo para fornecer o Arduino com informações do sensor.
Como o objetivo deste exercício é demonstrar a
web.py servidor para dados Arduino, não vamos utilizar o escudo Ethernet para a comunicação. Em vez disso, vamos capturar
os dados Arduino usando a interface serial, enquanto estiver usando o web.py servidor para responder às solicitações
provenientes de diferentes clientes. Como você pode ver no diagrama a seguir, estamos usando o mesmo hardware que
você projetado para o exercício 1, mas sem utilizar a conexão Ethernet para o nosso roteador em casa. Seu computador que
executa o web.py servidor, que também é uma parte da sua rede doméstica, irá servir as solicitações do cliente.

Na primeira etapa, vamos código Arduino para enviar periodicamente o valor do sensor de umidade para a
interface serial. Para o código Arduino, abra o
WebPySerialExample_Arduino.ino esboçar a partir da exercício 2 pasta do seu diretório de código. Como você pode ver no
seguinte trecho de código do esboço Arduino, estamos enviando os valores brutos do porta analógica para a
interface serial. Agora compilar e fazer o upload do esboço para sua placa Arduino. Abra o Serial monitor janela do
Arduino IDE para confirmar que você está recebendo as observações umidade matérias. Depois de ter confirmado
que, feche a Serial monitor janela. Você não será capaz de executar o código Python
se o Serial monitor janela é através da porta:

void loop () {
int analogChannel = 0;
int HIH4030_Value = analogRead (analogChannel); Serial.println
(HIH4030_Value); atraso (200); }

Depois que o código Arduino está funcionando corretamente, é hora de executar o programa Python, que contém o web.py
servidor. O programa Python para este exercício está localizado no
WebPySerialExample_Python diretório. Abra o webPySerialExample.py arquivo no seu editor de código. O programa Python está
organizado em duas seções: a captura de dados do sensor da interface serial usando o pyserial biblioteca e usando o web.py
servidor baseado em servidor para responder às solicitações dos clientes.

Na primeira fase do código, que está a interface da porta serial usando o Serial() método do pyserial biblioteca. Não se
esqueça de alterar o nome da porta serial como ele pode ser diferente para o seu computador, dependendo do
sistema operacional e porta física que você está usando:

série de importação
porto = serial.Serial ( '/ dev / tty.usbmodemfa1331', 9600, tempo limite = 1)

Uma vez o porta objeto para a porta serial é criado, o programa começa a ler o texto vindo da porta
física, usando o Leia a linha() método. usando o
humidade relativa() função, que convertem os dados de umidade matérias-se apropriar observações humidade relativa:

A linha = port.readline () se a linha:

Dados = flutuador (linha)

= humidade umidade relativa (linha, 25)

No lado do servidor web, iremos utilizar todos os principais web.py componentes que você aprendeu na seção anterior para
completar esse objetivo. Como parte disso, estamos implementando um formulário de entrada para o valor da temperatura.
Vamos capturar essa entrada do usuário e utilizá-lo com os dados brutos do sensor para calcular a umidade relativa.
Portanto, precisamos definir o render opor-se usar o modelo diretório. Neste exercício, estamos apenas usando a localização da
página de destino padrão ( '/') para o servidor web, que é direcionada para o Índice classe:

render = web.template.render ( 'modelos')

Como você pode ver na WebPySerialExample_Python pasta, temos um diretório chamado

modelos. Esta pasta contém um modelo com o base.html nome do arquivo. Como este é um arquivo HTML, é provável que se você
apenas clique sobre o arquivo, ele abre em um navegador web. Certifique-se de que você abra o arquivo em um editor de
texto. No arquivo aberto, você verá que estamos inicializar o arquivo de modelo com US $ def com (forma, humidade). Neste
inicialização, Formato
e umidade são variáveis ​de entrada que são necessários pelo modelo durante o processo de renderização.
O modelo declara o real < form> elemento com o $: form.render ()
método, ao exibir o valor da umidade usando o $ umidade variável:
<Form method = "POST">
$: Form.render () </ form>

<H3> Umidade Relativa do Ar é: </ h3> <nome p =

"temp"> $ umidade </ p>

Embora o arquivo de modelo torna o Formato variável, temos que definir esta variável no programa Python primeiro.
Como você pode ver no seguinte trecho de código, declaramos uma variável chamada enviar o formulário usando o form.Form
() método do web.py biblioteca. o
enviar o formulário variável inclui um Caixa de texto elemento para capturar o valor de temperatura e um
Botão elemento para permitir a ação de envio:

submit_form = form.Form (
form.Textbox ( 'Temperatura', Descrição = 'Temperatura'), form.button ( 'enviar', Tipo = "submeter",
description = 'enviar')
)

Quando você quiser acessar os valores apresentados atuais do enviar o formulário variável, você terá que validar
o formulário utilizando o valida () método:

f = self.submit_form ()
f.validates ()

Agora temos os componentes de página e de entrada da web voltados para o usuário projetado para o exercício. É
tempo para definir os dois métodos principais, OBTER e POSTAR, para responder ao pedido vindo da página web. Ao
iniciar ou atualizar a página web, o web.py servidor gera o OBTER pedido, o qual é então tratado pelo OBTER função do Índice class
Assim, durante a execução do OBTER método, o programa obtém o valor mais recente de humidade em bruto a partir
da porta de série e calcula a humidade relativa usando o humidade relativa() método.

Nota

No processo de lidar com a OBTER pedido, não estamos submetendo qualquer forma, com a entrada do usuário. Por
esta razão, na OBTER método, vamos usar o valor padrão de temperatura ( 25) para o humidade relativa() método.

Uma vez que o valor da umidade é derivado, o programa irá processar a base modelo utilizando o
render.base () função, tal como apresentado no seguinte fragmento de código, onde base() refere-se ao molde de base:

def GET (self):

f = self.submit_form ()
f.validates ()
A linha = port.readline () se a linha:

Dados = flutuador (linha)

= humidade umidade relativa (linha, 25) de retorno render.base (f,
humidade); outro:

retorno render.base (f, "Não dados válida");

Ao contrário do OBTER método, o POSTAR método é chamado quando o formulário é enviado para a página de web. A forma
apresentada inclui o valor de temperatura fornecida pelo utilizador, que
será usada para obter o valor da humidade relativa. Como o OBTER() função, o
POSTAR() função também torna o base modelo com o valor da umidade recente uma vez que a umidade é calculada:

def POST (self):

f = self.submit_form ()
f.validates ()
. Temperatura = f [ 'Temperatura'] = valor da linha de
port.readline () se a linha:

Dados = flutuador (linha)

= humidade umidade relativa (linha, flutuador (temperatura)) render.base retorno (f,
humidade); outro:

retorno render.base (f, "Não dados válida");

Agora é hora de executar o web.py- servidor web baseado. No programa Python, fazer as mudanças necessárias para
acomodar o nome da porta de série e quaisquer outros valores apropriados. Se tudo estiver configurado corretamente, você
será capaz de executar o programa a partir do terminal sem erros. Você pode acessar o servidor web, que está sendo
executado na porta 8080,
a partir de um navegador da web no mesmo computador, ou seja, http: // localhost: 8080. Agora, o objetivo do
exercício é para demonstrar a acessibilidade remota do servidor web de sua rede doméstica, e você pode
fazer isso abrindo o site a partir de outro computador na sua rede, isto é, http: // <ip-address>: 8080, onde < ip-address> refere-s
ao endereço IP do computador que está executando o web.py serviço.

Os shows tela acima, como o aplicativo web vai olhar quando aberto em um navegador da web. Quando você
carregar o site, você será capaz de ver um valor de humidade relativa obtida usando o OBTER método. Agora você
pode inserir um valor de temperatura adequada e pressione a enviar botão para chamar o POSTAR método. Na
execução bem-sucedida, você será capaz de ver o último valor da umidade relativa, que é calculado com base no
valor de temperatura que você enviou.
aplicações web RESTful com Arduino e
Python
No exercício anterior, implementamos o OBTER e POSTAR solicita usando o web.py
biblioteca. Estes pedidos são realmente parte da arquitetura de comunicação popular na maioria das Rede mundial de
computadores (WWW) chamado REST. A arquitetura implementos descansar um paradigma cliente-servidor usando o
protocolo HTTP para operações como POST, READ, e EXCLUIR.
o OBTER() e POSTAR() funções, implementado usando web.py, são subconjuntos funcionais destes operações de REST HTTP
padrão, ou seja, GET, POST, UPDATE, e EXCLUIR. A arquitetura REST está projetado para aplicações de rede, sites e
serviços web para estabelecer a comunicação através de chamadas baseadas em HTTP. Ao invés de ser apenas um
conjunto de regras padrão, a arquitetura RESTO utiliza tecnologias e protocolos da Web existente, tornando-se um
componente central da maioria dos sites que usamos hoje. Devido a esta razão, a WWW pode ser considerado o
maior implementação de arquitetura baseada em REST.
Designing RESTO baseada em aplicações Arduino
A arquitetura RESTO usa um modelo cliente-servidor, onde o servidor age como um nó centralizado na rede. Ele
responde às solicitações feitas pelos nós de rede distribuída (chamados clientes) essa consulta-lo. Neste paradigma, o
cliente inicia um pedido para o estado direcionado para o servidor, enquanto o servidor responde ao pedido do Estado
sem armazenar o contexto de cliente. Esta comunicação é sempre unidirecional e sempre iniciada a partir do lado do
cliente.

Para explicar melhor a transferência do Estado para a OBTER e POSTAR pedidos, veja o diagrama anterior. Quando um cliente envia uma OBTER
solicitação para um servidor usando uma URL, as responde de servidor com dados brutos como a resposta HTTP. Da mesma forma, na POSTAR
pedido, o cliente envia dados como carga útil para o servidor, enquanto o servidor responde com uma simples mensagem de
“confirmação recebido”.

métodos resto são relativamente simples de implementar e desenvolver usando chamadas HTTP simples. Vamos começar a
desenvolver Arduino aplicações de rede através de pedidos baseados em REST, como eles são fáceis de implementar e
entender e estão disponíveis diretamente através de exemplos. Vamos começar por implementar individualmente clientes
Arduino baseados em REST para HTTP baseado em OBTER e POSTAR métodos. Mais adiante neste capítulo, vamos passar por
um exercício para combinar o OBTER e POSTAR métodos através do mesmo cliente Arduino REST, ao desenvolver o servidor
HTTP utilizando web.py.
Trabalhando com o pedido GET do Arduino
Neste exercício, vamos implementar o HTTP OBTER cliente em Arduino, ao usar um servidor HTTP que foi
desenvolvido utilizando web.py. A premissa deste exercício de programação é usar a extensão Escudo Ethernet ea
biblioteca Ethernet para desenvolver um cliente Arduino HTTP física que suporta o OBTER solicitação.

O código Arduino para gerar a solicitação GET

Os navios Arduino IDE com alguns exemplos básicos que utilizam a biblioteca Ethernet. Um desses exemplos é Cliente
da web, que pode ser encontrado para navegar arquivo | Exemplos | Ethernet | Cliente da web. Ele foi concebido
para demonstrar a OBTER solicitar ao implementar o cliente HTTP no Arduino. Abra este esboço no Arduino IDE, como
estamos indo para usar este esboço e modificá-lo para acomodar o hardware Arduino criamos. A primeira coisa que
você precisa mudança no esboço aberto é o endereço IP eo endereço MAC do seu Arduino Ethernet Shield.
Substitua as seguintes variáveis ​com as variáveis ​apropriadas para o seu sistema. O seguinte trecho mostra o código
o endereço IP eo endereço MAC para o nosso hardware, e você precisará alterá-lo para acomodar sua:

byte mac [] = {0x90, 0xA2, 0xDA, 0x00, 0x47, 0x28}; IPAddress ip (10,0,0,75);

Como você pode ver, o exemplo usa o Google como um servidor para obter uma resposta. Você precisa alterar este endereço para
refletir o endereço IP do seu computador, que será o anfitrião da web.py servidor:

servidor char [] = "10.0.0.20";

No configuração() função, você terá que alterar o endereço IP do servidor novamente. Também alterar a porta HTTP padrão ( 80)
para a porta utilizada pelo web.py (8080):

if (client.connect (servidor, 8080)) {

Serial.println ( "ligado"); // Faz uma solicitação
HTTP:
client.println ( "GET / dados HTTP / 1.1"); client.println ( "Host:
10.0.0.20"); client.println ( "Connection: close"); client.println (); }

Depois de ter feito todas essas mudanças, vá para o Arduino_GET_Webpy \ ArduinoGET

pasta e abrir o ArduinoGET.ino esboço. Compare seu desenho modificado com este esboço e realizar as alterações
apropriadas. Agora você pode salvar o seu esboço e compilar o código por eventuais erros.

Nesta fase, estamos supondo que você tem o Arduino Ethernet Shield montado em seu Arduino Uno. Ligue a
blindagem Ethernet à sua rede local usando um cabo Ethernet, e Uno conectar com seu computador usando um
cabo USB. Carregar o esboço para a placa Arduino e abra a Serial monitor janela para verificar a atividade. Nesta
fase, Arduino não seria capaz de se conectar ao servidor, porque o seu web.py servidor ainda não está em
execução. Você pode fechar o monitor serial para agora.
O servidor HTTP utilizando web.py para manipular a solicitação GET

Em sua primeira web.py aplicativo, você desenvolveu um servidor que retornou Olá Mundo!
quando solicitados a partir de um navegador web. Apesar de todas as tarefas adicionais que podem ser executadas, o seu navegador
é um cliente HTTP em seu núcleo. Isto significa que se o seu primeiro web.py código do servidor foi capaz de responder ao OBTER pedido
feito pelo navegador da web, ele também deve ser capaz de responder ao cliente web Arduino. Para verificar isso, abra o seu primeiro web.py
programa,
webPyBasicExample.py, e alterar a seqüência de retorno de Olá Mundo! para teste. Estamos realizando esta mudança
string para diferenciá-lo dos outros casos deste programa. Execute o programa Python a partir do terminal e
aberto Serial monitor janela no Arduino IDE novamente. Desta vez, você será capaz de ver que o seu cliente
Arduino está recebendo uma resposta para o OBTER solicitá-lo enviado para o web.py servidor. Como você pode ver
na imagem seguinte, você será capaz de ver o teste corda impressa na Serial monitor

janela, que é devolvido pelo web.py servidor para o OBTER solicitação:

Embora neste exemplo, estamos a devolver uma cadeia simples para o OBTER pedido, você pode estender esse método para obter
diferentes parâmetros especificados pelo usuário do servidor web. este
OBTER aplicação podem ser utilizados num grande número de aplicações em que Arduino requer entrada repetida a partir
do utilizador ou outros programas. Mas e se o servidor web requer entrada do Arduino? Nesse caso, teremos que usar a POSTAR
solicitação. Vamos desenvolver um programa Arduino para acomodar o HTTP POSTAR solicitação.
Trabalhando com o pedido POST a partir Arduino
Uma vez que já tinham aplicado a OBTER pedido, podemos usar uma abordagem semelhante para o exercício do POSTAR solicitação.
Em vez de pedir o servidor para fornecer uma resposta para um pedido de estado, vamos enviar os dados do sensor de
carga de Arduino na implementação do
POSTAR solicitação. Da mesma forma, no lado do servidor, que irá utilizar web.py a aceitar a POSTAR
solicitar e exibi-lo através de um navegador web.

O código Arduino para gerar a solicitação POST

Abra o esboço Arduino ArduinoPOST.ino de Arduino_POST_Webpy \ ArduinoPOST

pasta do repositório de código. Como no exercício anterior, você primeiro terá que fornecer o endereço IP eo
endereço MAC do seu Arduino.

Depois de ter concluído estas mudanças básicas, observe o seguinte trecho de código para a implementação do POSTAR
solicitação. Você pode notar que estamos criando carga útil para o
POSTAR pedido como os dados variável a partir dos valores obtidos a partir de pino analógico 0:

dados de cadeia;
dados + = "";
dados + = "Humidade";
dados + = analogRead (analogChannel);

No seguinte código Arduino, vamos primeiro criar uma cliente objeto usando a biblioteca Ethernet. No recorrentes ciclo()
função, vamos usar este cliente objeto para se conectar à web.py
servidor em execução no nosso computador. Você terá que substituir o endereço IP no conectar()
método com o endereço IP do seu web.py servidor. Uma vez conectado, vamos criar um personalizado
POSTAR mensagem com os dados de carga útil foi calculado anteriormente. o Arduino ciclo()
função irá enviar periodicamente o valor do sensor atualizados gerado por este exemplo de código para o web.py servidor:

if (client.connect ( "10.0.0.20", 8080)) {

Serial.println ( "ligado");
client.println ( "POST / dados HTTP / 1.1"); client.println ( "Host:
10.0.0.20");
client.println ( "Content-Type: application / x-www-form-urlencoded"); client.println ( "Connection: close"); client.print (
"Content-Length:"); client.println (data.length ()); client.println (); client.print (dados); client.println ();

Serial.println ( "Dados enviados."); }

Depois de ter realizado as alterações, compilar e carregar este esboço para a placa Arduino. Enquanto o web.py servidor
ainda não está implementado, o POSTAR pedido que se originou a partir de Arduino não vai ser capaz de chegar ao seu
destino com sucesso, então vamos criar o web.py
servidor para aceitar POSTAR solicitações de.

O servidor HTTP utilizando web.py para manipular a solicitação POST

Nesta implementação do POSTAR método, que exigem dois web.py Aulas, índice e
dados, para servir individualmente pedidos de navegador web e Arduino, respectivamente. Como estamos indo para usar duas
classes separadas para atualizar valores comuns de sensores (isto é,
umidade e temperatura), vamos declará-los como variáveis ​globais:

temperatura global, temperatura humidade = 25

Como você deve ter notado no código Arduino ( client.println ( "POST / dados HTTP / 1.1")), estávamos enviando o POSTAR pedido
para o URL localizado em / dados. Da mesma forma, vamos usar o local raiz padrão, '/', desembarcar qualquer pedido
proveniente do navegador da web. Estas solicitações para o local raiz será tratado pelo índice classe, assim como nós
coberto de exercício 2:

URLs = (
'/', 'Índice de', '/ dados',
'dados',
)

o dados classe cuida de qualquer POSTAR pedido proveniente da / dados localização. Neste caso, estes POSTAR pedidos
conter carga útil que tem a informação do sensor ligado pelo Arduino POSTAR cliente. Ao receber a mensagem, o
método divide a seqüência de carga para o sensor do tipo e valor, a actualização do valor global do umidade variável
neste processo:

dados de classe:
def POST (self):
humidade global, i = web.input () =
dados web.data () Dados = data.split ()
[1]

= humidade umidade relativa (dados, temperatura) Humidade retorno

Cada POSTAR solicitação recebida do Arduino atualiza o valor da umidade cru, que é representada pela dados variável.
Estamos a utilizar o mesmo código de exercício 2 para se obter os valores de temperatura a partir de manuais do
utilizador. O valor de humidade relativa, umidade, é atualizado de acordo com o valor da temperatura lo atualizado usando
o navegador web e o valor da umidade bruto é obtido a partir do seu Arduino.
Para verificar o código Python, abra o WebPyEthernetPOST.py arquivo a partir do repositório de código. Depois de fazer as
alterações apropriadas, executar o código a partir do terminal. Se você não começar a receber as atualizações do
Arduino no terminal, você deve reiniciar Arduino para restabelecer a conexão com o web.py servidor. Uma vez que você
começar a ver atualizações periódicas do Arduino POSTAR pedidos no terminal, abra a localização da aplicação web no
seu browser. Você será capaz de ver algo semelhante à captura de tela anterior. Aqui, você pode enviar o valor da
temperatura manual, utilizando o formulário, enquanto o navegador irá recarregar com a umidade relativa atualizado
de acordo com o valor da temperatura entrou.
Exercício 3 - uma aplicação web RESTful Arduino
O objetivo deste exercício é simplesmente combinar o OBTER e POSTAR métodos que você aprendeu nas duas seções
anteriores, a fim de criar uma experiência de descanso completo usando Arduino e Python. A arquitetura para este
exercício pode ser descrito da seguinte forma:

O cliente Arduino usa periodicamente o OBTER solicitar para obter o tipo de sensor a partir do servidor. Ele usa este tipo de
sensor para selecionar um sensor para observação. No nosso caso, é tanto um sensor de umidade ou movimento. Os
responde servidor Web para o OBTER solicitar, retornando o tipo de sensor de corrente do sensor selecionado pelo usuário.
O usuário fornece esta seleção através de uma aplicação web.

Depois de receber o tipo de sensor, os utiliza cliente Arduino POSTAR para enviar observação sensor para o
servidor. O servidor web recebe o POSTAR dados e atualiza a observação de sensor para que tipo de sensor
específico.

No lado do usuário, o servidor web obtém o tipo de sensor de corrente através do navegador web.
Quando o enviar botão no navegador é pressionado, o servidor atualiza o valor do sensor no navegador
com o último valor.

O esboço Arduino para o exercício

Usando o mesmo hardware Arduino nós construímos, abra o Arduino esboço chamado
WebPyEthernetArduinoGETPOST.ino de Exercício 3 - aplicação RESTful Arduino e webpy pasta de código. Como descrevemos
na arquitetura do exercício anterior, o cliente Arduino deve enviar periodicamente OBTER pedidos para o
servidor e obter o valor correspondente do tipo de sensor na resposta. Depois de comparar o tipo de
sensor, o cliente Arduino busca a observação sensor de corrente com os pinos do Arduino e envia essa
volta observação para o servidor usando POST: if (client.connected ()) {

if (Client.find ( "umidade")) {
# Fetch valor sensor de umidade se (client.connect ( "10.0.0.20",
8080)) {
# Aplicar os seus valores de umidade}} outro{ #

Fetch valor sensor de movimento

if (client.connect ( "10.0.0.20", 8080)) {

# Aplicar os seus valores de movimento}}

# Add atraso}

Depois de alterar o endereço IP do servidor apropriado no código, compilar e fazer o upload para o Arduino. Abra o Serial
monitor janela, onde você vai encontrar tentativas de conexão malsucedidas, como seu web.py servidor ainda não está em
execução. Feche qualquer outra instância ou
programa do web.py servidor em execução no computador.

A aplicação web.py às solicitações suporte a REST

Abra o WebPyEthernetGETPOST.py arquivo do Exercício 3 - aplicação RESTful Arduino e webpy pasta de código. Como você
pode ver, o web.py implementos servidor Web baseado duas classes distintas, índice e dados, para suportar a
arquitetura REST para o navegador web eo cliente Arduino, respectivamente. Estamos introduzindo um novo
conceito para a
Formato elemento, chamado Suspenso(). usando este Formato método, você pode implementar o menu de seleção para baixo
drop e pedir que o usuário selecione uma opção da lista de opções:

form.Dropdown ( 'drop-down',
[( 'Humidade', 'Humidade'), ( 'movimento', 'Motion')]),
form.button ( 'enviar',
type = "submit", description = 'enviar'))

No anterior web.py programa, implementamos o OBTER e POSTAR métodos para o índice

classe e apenas o POSTAR método para o dados classe. Avançando neste exercício, nós também vamos adicionar o OBTER método
para o dados classe. Esse método retorna o valor da
sensorType quando a variável OBTER solicitação é feita para o / dados localização. Do lado do usuário, o valor da sensorType variável
é atualizado quando o formulário obtém enviado com uma opção. Esta ação envia um valor selecionado para o POSTAR
método do índice classe, em última análise, a actualização do sensorType valor:

dados de classe:
def GET (self):
retorno sensorType def POST
(self):
humidade global, movimento i = web.input () data
= web.data () data = data.split () [1] se
sensorType == "Umidade":

= humidade umidade relativa (dados, temperatura) retorno de humidade mais: movimento

= dados

retorno movimento

Antes de executar este programa Python, certifique-se de ter verificado todos os componentes do código e atualizou os
valores quando necessário. Em seguida, executar o código a partir do terminal. Seu servidor web agora será executado
em seu computador local no número de porta 8080. -Ciclo de energia o dispositivo Arduino no caso da tentativa de conexão
de Arduino falhar. Para testar o sistema, abra o aplicativo web do seu navegador web. Você verá uma página web aberta
no navegador, como mostrado na imagem seguinte:
Você pode escolher o tipo de sensor do suspenso cardápio ( Umidade ou Movimento) antes de pressionar o Enviar botão.
Aquando da apresentação, você será capaz de ver a página atualizada com o tipo de sensor apropriado e seu valor
atual.
Por que precisamos de um protocolo de mensagens com recursos limitados?

Na seção anterior, você aprendeu a usar o HTTP DESCANSAR arquitetura para enviar e receber dados entre o
Arduino eo servidor host. O protocolo HTTP foi originalmente concebido para servir de dados textuais através
de páginas da web na Internet. O mecanismo de fornecimento de dados utilizado por HTTP requer uma
comparativamente grande quantidade de computação e os recursos de rede, que podem ser suficientes para
um sistema de computador, mas não para as plataformas de hardware constrangimentos de recursos, tais
como Arduino. Como discutimos anteriormente, o paradigma cliente-servidor implementada pela arquitetura
HTTP REST cria um sistema fortemente acoplado. Neste paradigma, ambos os lados (cliente e servidor)
precisa ser constantemente ativo, ou ao vivo, para responder. Além disso, a arquitetura RESTO só permite a
comunicação unidirecional do cliente ao servidor, onde os pedidos são sempre inicializado pelo cliente e as
responde servidor para o cliente.

Estes dispositivos devem evitar modo de comunicação ativa para economizar energia A comunicação deve ter menos
revisão de dados para economizar recursos de rede Eles geralmente não têm recursos computacionais suficientes para
permitir a comunicação RESTO bidirecional, ou seja, a implementação de ambos os mecanismos de cliente e servidor
em cada lado

O código deve ter um espaço menor devido às limitações de armazenamento

Gorjeta

A arquitectura baseada em REST ainda pode ser útil quando a aplicação requer especificamente uma arquitetura de
pedido-resposta, mas a maioria das aplicações de hardware baseados em sensores estão limitadas devido aos pontos
anteriores.

Entre outros paradigmas de entrega de dados que resolvam os problemas anteriores, a arquitetura baseada em publisher
/ assinante (Pub / sub) está alto. O pub / sub arquitectura permite capacidades de comunicação bidireccional entre
o nó que gera os dados ( Editor) eo nó que consome os dados ( Assinante). Nós estamos indo para usar MQTT
como o protocolo que utiliza a sub modelo de transporte mensagem pub /. Vamos começar por cobrindo o sub
arquitetura pub / e MQTT em detalhe.
MQTT - Um protocolo de mensagens leve
Assim como REST, pub / sub é um dos a maioria dos padrões de mensagens populares, principalmente implantados para
transferir mensagens curtas entre os nós. Em vez de implantar arquitetura baseada em cliente-servidor, os implementos paradigma
pub / sub mensagens middleware chamado de corretor para receber, fila e retransmitir mensagens entre os clientes do assinante e
editor:

O pub / sub arquitetura utiliza um sistema baseado em tópico para selecionar e processar mensagens, onde cada
mensagem é rotulada com um nome de tópico específico. Em vez de enviar uma mensagem diretamente para o
assinante, o editor envia-lo primeiro para o corretor com um nome do tópico. Em um processo totalmente independente, o
assinante registra sua subscrição de tópicos específicos com o corretor. No caso de receber uma mensagem da editora,
os executa corretor tópico baseado em filtragem em que a mensagem antes de encaminhá-lo para os assinantes
registrados para esse tópico. Como editores são vagamente acoplado a assinantes Nesta arquitetura, os editores não
precisa saber o paradeiro dos assinantes e pode trabalhar sem interrupções sem se preocupar com o seu estatuto.

Ao discutir as limitações da arquitetura REST, percebemos que requer a implementação de tanto o cliente
HTTP e servidor no final Arduino para permitir a comunicação bidirecional com Arduino. Com a arquitetura
baseada corretor demonstrado pelo pub / sub, você só precisa implementar o código leve para o editor ou
cliente assinante em Arduino, enquanto o corretor pode ser implementado em um dispositivo com mais
recursos de computação. Daí em diante, você terá a comunicação bidirecional ativada no Arduino sem o uso
de recursos significativos.
Introdução ao MQTT
Message Queue Telemetry Transport (MQTT) é um fácil, ea aplicação muito simples, aberta do pub /
sub paradigma. IBM tem vindo a trabalhar em padronizar e que suporta o protocolo MQTT. A
documentação para o mais recente especificação do MQTT protocolo, v3.1, podem ser obtidas no site
oficial MQTT em
http://www.mqtt.org .

Como um padrão para mensagens máquina, MQTT é projetado para ser extremamente leve e com um espaço menor para o
código, ao mesmo tempo, usando uma largura de banda de rede inferior para a comunicação. MQTT é muito
especificamente projetado para funcionar em sistemas como embutidos plataformas de hardware, como Arduino ou outros
aparelhos que carregam recursos de processador e memória limitados. Enquanto MQTT é um protocolo de mensagens da
camada de transporte, ele usa TCP / IP para conectividade em nível de rede. Como MQTT é projetado para suportar o pub /
sub paradigma de mensagens, a implementação de MQTT em sua aplicação hardware fornece suporte para um-para-muitos
de mensagens distribuído, eliminando a limitação da comunicação unidirecional demonstrado por HTTP REST. Como MQTT
é agnóstico do conteúdo da carga, não há nenhuma restrição sobre o tipo de mensagem que pode passar usando esse
protocolo. Devido a todos os benefícios associados com o pub sub paradigma / e sua implementação no protocolo MQTT,
estaremos usando o protocolo MQTT para o resto dos exercícios para que as mensagens transmitidas entre o Arduino e seu
computador em rede. Para conseguir isso, vamos estar usando o corretor MQTT para fornecer as bases para temas de
comunicação de mensagens e de acolhimento, ao implantar o editor MQTT e clientes assinantes nas extremidades Arduino e
Python.
Mosquitto - um MQTT corretor open source
Como descrevemos, MQTT é apenas um padrão de protocolo, e ainda requer ferramentas de software para que ele
possa ser implementado em aplicações reais. mosquitto é uma implementação open source do corretor de mensagem,
que suporta a versão mais recente do protocolo padrão MQTT. O corretor mosquitto permite o pub / sub paradigma
implementado pelo protocolo MQTT, proporcionando um mecanismo de leve para permitir que mensagens entre
máquinas. Desenvolvimento de mosquitto é suportado através de esforços da comunidade. Mosquitto é um dos mais
implementações MQTT populares, livremente disponível e amplamente apoiada na Internet. Pode obter mais
informações sobre a ferramenta real e da comunidade de seu site, em http://www.mosquitto.org .
Configurando mosquitto
A instalação e configuração do mosquitto são processos muito simples. Na hora de escrever este livro, a
última versão do mosquitto é 1.3.4. Você também pode obter as últimas atualizações e instalação
informações sobre mosquitto em
http://www.mosquitto.org/download/ .

No Windows, você pode simplesmente baixar a versão mais recente dos arquivos de instalação para Windows, que é
feito para sistemas Win32 ou Win64. Baixe e execute o arquivo executável para instalar o corretor mosquitto. Para
executar mosquitto no prompt de comando, você terá que adicionar o diretório mosquitto ao CAMINHO variáveis ​nas
variáveis ​de ambiente das propriedades do sistema. Dentro Capítulo 1 , Introdução ao Python e Arduino, nós
exaustivamente descrito o processo de adição de um CAMINHO variável para instalar Python. Usando o mesmo método,
adicione o caminho do diretório de instalação mosquitto no final do

CAMINHO valor. Se você estiver usando um sistema operacional de 64 bits, você deve usar C: \ Arquivos de Programas (x86) \ mosquitto. Para
um sistema operacional de 32 bits, você deve usar C: \ Program Files \ mosquitto como o caminho. Uma vez que você é feito com a
adição deste valor no final do
CAMINHO valor, feche todas as janelas existentes Prompt de Comando e abrir uma nova janela do prompt de
comando. Você pode validar a instalação, digitando o seguinte comando na janela recém-aberta. Se tudo estiver
instalado e configurado corretamente, o seguinte comando deve ser executado sem erros:

C: \> mosquitto

Para Mac OS X, a melhor maneira de instalar mosquitto é usar a ferramenta Homebrew. Nós já passou pelo
processo de instalação e configuração do Homebrew no Capítulo 1 , Introdução ao Python e Arduino. Instalar o
corretor mosquitto simplesmente executando o seguinte script no terminal. Este script irá instalar mosquitto com
os utilitários mosquitto e também configurá-los para executar a partir do terminal de comandos:

$ Brew instalar mosquitto

No Ubuntu, o repositório padrão já tem o pacote de instalação para mosquitto. Dependendo da versão do Ubuntu você
está usando, esta versão mosquitto poderia ser mais velho do que a versão atual. Nesse caso, você deve adicionar este
repositório em primeiro lugar:

$ sudo apt-add repositório ppa: mosquitto-dev / mosquitto-ppa $ sudo apt-get update

Agora você pode instalar os pacotes mosquitto simplesmente executando o seguinte comando:

$ Sudo apt-get install mosquitto mosquitto-clientes

Familiarize-se com mosquitto
Devido aos vários métodos de instalação envolvidos para diferentes sistemas operacionais, a inicialização de mosquitto
pode ser diferente para sua instância. Em alguns casos, mosquitto pode já estar em execução no seu computador. Para um
sistema operacional baseado em Unix, você pode verificar se mosquitto está funcionando ou não com este comando:

$ Ps aux | grep mosquitto

A menos que você encontrar uma instância em execução do corretor, você pode começar mosquitto executando o seguinte
comando no terminal. Após executá-lo, você deve ser capaz de ver o corretor correndo ao imprimir os parâmetros de
inicialização e outras solicitações próximos a ele:

$ mosquitto

Quando você instalou o corretor mosquitto, o processo de instalação também teria instalado alguns utilitários
mosquitto, que incluem os clientes MQTT para o editor e o assinante. Estes utilitários de cliente pode ser usado
para se comunicar com qualquer corretor mosquitto.

Para usar o utilitário de cliente assinante, mosquitto_sub, use o seguinte comando no terminal com o endereço IP
do corretor mosquitto. Como estamos nos comunicando com o corretor mosquitto em execução no mesmo
computador, você pode evitar a -h <Broker-IP>
opção. O utilitário de assinante utiliza o -t opção para especificar o nome do tema que você está planejando para se
inscrever. Como você pode ver, estamos assinando o teste tema:

$ Mosquitto_sub -h <Broker-IP> teste -t

Semelhante ao cliente assinante, o cliente publisher ( mosquitto_pub) pode ser usado para publicar uma mensagem para
o corretor para um tópico específico. Conforme descrito no seguinte comando, que são obrigados a usar o -m opção
seguida por uma mensagem de publicá-lo com sucesso. Neste comando, estamos publicando uma Olá mensagem para
o teste tema:

$ Mosquitto_pub -h <Broker-IP> teste -t ​-m Olá

Outras utilidades importantes incluem mosquitto mosquitto_password e mosquitto.conf,

que pode ser usado para gerenciar os arquivos de senha mosquitto e a configuração da corretora,
respectivamente.
Começando com MQTT em Arduino e Python

Agora que você tem o corretor mosquitto instalado no seu computador, isso significa que você tem um corretor de trabalho
que implementa o protocolo MQTT. Nosso próximo objetivo é desenvolver os clientes MQTT em Arduino e também em
Python para que eles vão trabalhar como editores e assinantes. Depois de implementar os clientes MQTT, teremos um
sistema MQTT totalmente funcional, onde esses clientes se comunicam através do corretor mosquitto. Vamos começar com
a implantação MQTT na plataforma Arduino.
MQTT em Arduino usando a biblioteca PubSubClient
Como MQTT é um protocolo de mensagens baseado em rede, você sempre terá um escudo Ethernet para se
comunicar com sua rede. Para o exercício seguinte, vamos continuar usando o mesmo hardware que temos vindo
a utilizar ao longo deste capítulo.

A instalação da biblioteca PubSubClient

Para usar o Arduino para pub / sub e permitir mensagens MQTT simples, você precisa a biblioteca cliente Arduino para
MQTT, também conhecido como o PubSubClient biblioteca. o PubSubClient
biblioteca ajuda a desenvolver Arduino como um cliente MQTT, que pode então comunicar com o servidor MQTT
(mosquitto corretor no nosso caso) em execução no computador. Como a biblioteca fornece métodos para criar apenas um
cliente MQTT e não um corretor, a pegada do código Arduino é muito pequena em comparação com outros paradigmas de
mensagens. o PubSubClient
biblioteca extensivamente utiliza a biblioteca e implementos Arduino Ethernet padrão, o cliente MQTT como uma
subclasse de cliente Ethernet. Para começar com o PubSubClient biblioteca, primeiro você precisa importar a biblioteca
para o seu Arduino IDE. Baixar a versão mais recente do PubSubClient biblioteca Arduino de

https://github.com/knolleary/pubsubclient/ . Assim que tiver o arquivo baixado, importá-lo para o seu Arduino IDE.

Nós estaremos usando um dos exemplos instalados com o PubSubClient biblioteca para começar. O objetivo do exercício é
utilizar um exemplo básico para criar um cliente Arduino MQTT, durante a execução de pequenas modificações para
acomodar os parâmetros de rede locais. Nós, então, usar os comandos mosquitto que você aprendeu na seção anterior
para testar o cliente Arduino MQTT. Enquanto isso, garantir que o seu corretor mosquitto está sendo executado em
segundo plano.

Desenvolver o cliente Arduino MQTT

Vamos começar com a abertura do mqtt_basic exemplo por navegar para arquivo | Exemplos | PubSubClient em nosso
menu Arduino IDE. No programa aberto, alterar os valores de endereço MAC e IP para Arduino através da actualização
do Mac[] e ip [] variáveis, respectivamente. Na seção anterior, você instalou com sucesso e testado o corretor mosquitto.
Use o endereço IP do computador que executa mosquitto para atualizar o servidor[] variável:

byte mac [] = {0x90, 0xA2, 0xDA, 0x0D, 0x3F, 0x62};

servidor byte [] = {10, 0, 0, 20}; IP BYTE []
= {10, 0, 0, 75};

Como você pode ver no código, estamos inicializar o cliente usando o endereço IP do servidor, número da porta mosquitto,
eo cliente Ethernet. Antes de utilizar qualquer outro método para a
PubSubClient biblioteca, você sempre terá que inicializar o cliente MQTT usando um método semelhante:

EthernetClient ethClient;
cliente PubSubClient (servidor de 1883, chamada de retorno, ethClient);

Mais adiante no código, estamos usando o publicar() e se inscrever() métodos no

cliente classe para publicar uma mensagem para o outTopic tópico e subscrever o inTopic
tema. Você pode especificar o nome do cliente usando o client.connect () método. Como você pode ver no seguinte
trecho de código, estamos declarando arduinoClient como o nome para este cliente:

Ethernet.begin (mac, ip);

if (client.connect ( "arduinoClient")) {
client.publish ( "outTopic", "Olá mundo"); client.subscribe ( "inTopic"); }

Como estamos usando este código no configuração() função, o cliente só irá publicar o Olá Mundo mensagem de uma
vez durante a inicialização do código-enquanto o se inscrever método irá manter a procura de novas mensagens
para inTopic devido ao uso do client.loop ()
método no Arduino ciclo() função:

client.loop ();

Agora, durante a execução mosquitto no fundo, abrir outra janela de terminal. Nesta janela de terminal, execute o
seguinte comando. Este comando irá usar um cliente mosquitto baseado em computador para se inscrever no outTopic
tema:

$ Mosquitto_sub -t "outTopic"

Compilar seu esboço Arduino e enviá-lo. Assim que o processo de upload estiver completo, você será capaz
de ver o Olá Mundo corda impressa. Basicamente, assim que o código Arduino começa a funcionar, o cliente
Arduino MQTT irá publicar o Olá Mundo string para o corretor mosquitto para o outTopic tema. Por outro lado, isto
é, no lado do cliente mosquitto, você começou a usar o mosquitto_sub utilidade e irá receber esta mensagem,
uma vez que está inscrito outTopic.

Embora você executou o exemplo Arduino modificado, mqtt_basic, você também pode encontrar o código para este exercício
a partir da pasta de código deste capítulo. Neste exercício, o cliente Arduino também está inscrito inTopic para receber
qualquer mensagem que se origina para este tópico. Infelizmente, o programa não exibir ou lidar com mensagens que
obtenha na assinante. Para testar as funcionalidades do assinante do cliente Arduino MQTT, vamos abrir o mqtt_advance

esboço Arduino da pasta de código deste capítulo.

Como você pode ver no seguinte trecho de código, nós adicionamos código para exibir a mensagem recebida no ligue
de volta() método. o ligue de volta() método será chamado quando o cliente recebe qualquer mensagem dos temas
inscritos. Portanto, você pode implementar todos os tipos de funcionalidade na mensagem recebida do ligue de volta() método:

de chamada de retorno vazio (char * tópico, byte * carga, comprimento unsigned int) {
// mensagem alça chegou Serial.print
(tópico); Serial.print ( ':');

Serial.write (carga, comprimento); Serial.println (); }

Nisso mqtt_advance Arduino esboço, nós também mudaram a declaração da publicação de

outTopic a partir de configuração() ao ciclo() função. Esta acção irá ajudar-nos a publicar periodicamente o valor para outTopic. No
futuro, vamos expandir este método para informações do sensor uso como mensagens para que os outros dispositivos
podem obter esses valores do sensor, assinando esses tópicos de sensores:

void loop ()
{Client.publish ( "outTopic", "From Arduino");

atraso (1000); client.loop

(); }

Após atualizar o mqtt_advance esboçar com os endereços de rede apropriados, compilar e fazer o upload do esboço para
o seu hardware Arduino. Para testar o cliente Arduino, use o mesmo
mosquitto_sub comando para subscrever outTopic. Desta vez, você vai periodicamente obter atualizações para outTopic
no terminal. Para verificar a funcionalidade assinante do seu cliente Arduino, abra o Serial monitor janela no
seu Arduino IDE. Uma vez o Serial monitor janela começa a ser executado, execute o seguinte comando no
terminal:

$ Mosquitto_pub - t "inTopic" -m "Test"

Você pode ver no Serial monitor janela que o Teste texto é impresso com o nome do tópico como inTopic. Daí em diante, o
Arduino vai servir tanto como uma editora MQTT e um assinante MQTT. Agora vamos desenvolver um programa
Python para implementar os clientes MQTT.
MQTT em Python utilizando paho-MQTT
No exercício anterior, testamos o cliente Arduino MQTT usando utilitários de linha de comando. A menos que as mensagens
publicadas e subscritas são capturados em Python, não podemos utilizá-los para desenvolver todas as outras aplicações que
construímos até agora. Para transferir mensagens entre o corretor mosquitto e o interpretador Python, usamos uma biblioteca
Python chamada pahomqtt. Esta biblioteca costumava ser chamado mosquitto-pitão antes que ele foi doado para o projeto da OPAS.
Idêntica à biblioteca cliente Arduino MQTT, o paho-MQTT biblioteca fornece métodos semelhantes para desenvolver o cliente
MQTT pub / sub usando Python.

Instalando paho-MQTT

Como todas as outras bibliotecas Python que usamos, paho-MQTT Também pode ser instalado usando Setuptools. Para instalar a

biblioteca, execute este comando no terminal:

$ Pip sudo instalar paho-MQTT

Para o sistema operacional Windows, use easy_install.exe para instalar a biblioteca. Uma vez instalado, você pode
verificar a instalação bem-sucedida da biblioteca usando o seguinte comando no terminal interativo do Python:

> > > paho.mqtt.client importação

Usando a OPAS-MQTT biblioteca Python

o paho-MQTT biblioteca Python fornece métodos muito simples para se conectar ao seu corretor mosquitto. a céu aberto
Vamos mqttPython.py arquivo da pasta de código deste capítulo. Como você pode ver, temos inicializado o código
importando o paho.mqtt.client método de biblioteca:

paho.mqtt.client importação como mq

Assim como a biblioteca Arduino MQTT, o paho-MQTT biblioteca também fornece métodos para ligar para o corretor
mosquitto. Como você pode ver, nós nomeamos nosso cliente
mosquittoPython simplesmente usando o Cliente() método. A biblioteca também fornece métodos para atividades, por
exemplo, quando o cliente recebe uma mensagem, ON_MESSAGE, e publica uma mensagem, on_publish. Depois de ter
inicializado esses métodos, você pode conectar seu cliente para o servidor mosquitto especificando o endereço IP do
servidor eo número da porta.

Para subscrever ou publicar para um tópico, você simplesmente precisa para implementar o se inscrever() e
publicar() métodos no cliente, respectivamente, conforme apresentado no seguinte trecho de código. Neste exercício, estamos
usando o loop_forever () método para o cliente para verificar periodicamente o corretor para quaisquer novas mensagens. Como
você pode ver no código, estamos executando o
publishTest () função antes do controlo entra no ciclo de:

cli = mq.Client ( 'mosquittoPython')

cli.on_message = onMessage
cli.on_publish = onPublish
cli.connect ( "10.0.0.20", 1883, 15)
cli.subscribe ( "outTopic", 0) publishTest ()
cli.loop_forever ()

É muito importante para executar todas as funções ou partes de código necessárias antes de entrar no loop, como o
programa vai entrar no circuito com o servidor mosquitto uma vez loop_forever () É executado. Durante este período, o
cliente só irá executar o on_publish e ON_MESSAGE
métodos para qualquer atualização sobre a subscritas ou tópicos publicados.

Para superar esta situação, estamos implementando o paradigma multithreading da linguagem de programação Python.
Embora nós não estamos indo para mergulho profundo no multithreading, o exemplo a seguir vai ensinar-lhe o suficiente
para implementar a lógica de programação básica. Para entender mais sobre o Python rosqueamento biblioteca e métodos
suportados, visita https://docs.python.org/2/library/threading.html .

Para entender melhor a nossa implementação do método de segmentação, visite o seguinte trecho de código. Como você
pode ver no código, estamos implementando recursão para o
publishTest () funcionar a cada 5 segundos, usando o Cronômetro() método de encadeamento. Usando este método, o
programa irá iniciar um novo segmento que é separado do thread principal programa que contém o loop para mosquitto.
A cada 5 segundos, o publishTest () função será executada, de forma recursiva executar o publicar() método, e, finalmente, a
publicação de uma mensagem para inTopic:

rosqueamento importação def

publishTest ():
cli.publish ( "inTopic", "From Python") threading.Timer (5,
publishTest) .start ()

Agora, no segmento principal, quando o cliente recebe uma nova mensagem dos tópicos subscritas, a thread invoca o onMessage
() função. Na implementação atual desta função, estamos apenas imprimir o assunto e mensagem para fins de demonstração.
Em aplicações reais, esta função pode ser usada para implementar qualquer tipo de operação na mensagem recebida, por
exemplo, escrever uma mensagem para um banco de dados, executando um comando Arduino, selecionando uma entrada,
chamando outras funções, e assim por diante. Em suma, esta função é o ponto de entrada de qualquer entrada que você
recebe através do corretor mosquitto de seus tópicos subscritas:

def onMessage (mosq, obj, msg):

imprimir msg.topic + ":" + msg.payload

Da mesma forma, cada vez que você publicar uma mensagem a partir do segundo segmento, o onPublish ()

função é executada pelo programa. Assim como a função anterior, você pode implementar várias operações dentro desta
função, enquanto a função comporta-se como o ponto de saída de qualquer mensagem publicada usando este cliente
Python MQTT. Na implementação atual do
onPublish (), não estamos de efectuar qualquer operação:

def onPublish (mosq, obj, mid):

passar

No arquivo Python aberto, mqttPython.py, você só precisará alterar o endereço IP do servidor que executa o corretor mosquitto.
Se você estiver executando o corretor mosquitto no mesmo computador, você pode usar 127.0.0.1 como o endereço IP do
localhost. Antes de executar este arquivo Python, garantir que o seu Arduino está sendo executado com o cliente MQTT
que criou no exercício anterior. Uma vez que você executar esse código, você pode começar a ver as mensagens
sejam enviadas do seu Arduino no terminal Python, como mostrado na imagem seguinte. Sempre que uma nova
mensagem é recebida, o programa Python imprime o outTopic
nome do tópico seguido pelo De Arduino mensagem. Isso confirma que o cliente Python está a receber mensagens de outTopi
ao qual está inscrito. Se você olhar para trás, o código Arduino, você vai notar que ele é a mesma mensagem que
estávamos publicando a partir do cliente Arduino.

Agora, para confirmar a operação de publicação do cliente Python MQTT, vamos abrir o Serial monitor janela do
seu Arduino IDE. Como você pode ver na Serial monitor janela, texto que contém o inTopic nome do tópico e do De
Python mensagem está sendo impressa a cada 5 segundos. Isso valida a editora Python, como estamos
publicando a mesma mensagem para o mesmo tema a cada 5 segundos através do publishTest () função.
Exercício 4 - MQTT gateway para Arduino
No exercício 3, foi utilizada a arquitetura REST para o movimento de transferência e umidade sensor de dados entre a
nossa Arduino e navegador web. Neste exercício, iremos desenvolver um gateway MQTT usando o corretor mosquitto e
os clientes MQTT a informação do sensor de transferência do nosso Arduino para o navegador web. O objetivo do
exercício é replicar os mesmos componentes que nós implementadas no exercício REST, mas com o protocolo MQTT.
Como você pode ver no desenho arquitectónico do sistema, temos Arduino com o escudo Ethernet ligado à nossa rede
de casa, enquanto o computador está executando o corretor mosquitto e as aplicações Python na mesma rede. Estamos
usando os mesmos sensores (isto é, um sensor de movimento e um sensor de umidade) eo mesmo design de hardware
que usamos nos exercícios anteriores neste capítulo.

Na arquitectura de software, que tem o código Arduino que faz interface com os sensores de humidade e de movimento
utilizando pino analógico 0 e pino digital 3, respectivamente. usando o
PubSubClient biblioteca, o Arduino publica informações do sensor para o corretor mosquitto. Na MQTT Gateway, temos dois
programas diferentes Python em execução no computador. O primeiro programa usa o paho-MQTT biblioteca para
inscrever-se e recuperar informações do sensor do corretor mosquitto e depois postar -lo para a aplicação web. O segundo
programa Python, que se baseia na web.py, implementa as aplicações de web, enquanto a obtenção de valores do sensor a
partir do primeiro programa Python. Este programa fornece uma frente interface de usuário
para o MQTT Gateway.

Embora ambos os programas em Python anteriores pode ser parte de uma única aplicação, nós estamos delegando
as tarefas de comunicação com mosquitto e servindo informações usando o aplicativo da Web para aplicações
separadas pelas seguintes razões:

Queremos demonstrar as funções de ambas as bibliotecas, paho-MQTT e web.py, em aplicações separadas

Se você deseja executar rotinas com base em paho-MQTT e web.py na mesma aplicação, você terá que implementar
multithreading, como ambas as rotinas precisam ser executados de forma independente

Nós também queremos demonstrar a transferência de informações entre os dois programas em Python usando
métodos de REST baseados em Python, com a ajuda do httplib biblioteca

Neste exercício, estamos rotulando umidade e sensor de movimento informações com os rótulos tópico Arduino / humidade e Arduino
movimento /, respectivamente. O editor MQTT baseado em Arduino eo assinante MQTT baseado em Python estará
utilizando estes nomes de tópicos se eles querem transferir informações através do corretor mosquitto. Antes de
começar com a implementação do cliente MQTT em nosso Arduino, vamos começar o corretor mosquitto em nosso
computador.

Desenvolvimento Arduino como o cliente MQTT

O objetivo do cliente Arduino MQTT é publicar periodicamente os dados de umidade e de movimento para o
corretor mosquitto em execução no computador. Abra o Step1_Arduino.ino
esboçar a partir da Exercício 4 - MQTT portal pasta em seu repositório de código. Como todos os outros exercícios, você primeiro
precisa mudar o endereço MAC e o valor do endereço do servidor, e atribuir um endereço IP para o seu cliente Arduino. Uma
vez que você é feito com essas modificações, você pode ver a configuração() função que estamos publicando como uma
mensagem de conexão única para o corretor mosquitto para verificar a ligação. Você pode implementar uma função
semelhante em uma base periódica, se você tem um problema com a manutenção de sua conexão mosquitto vivo:

if (client.connect ( "Arduino")) {
client.publish ( "Arduino / ligação", "Ligado".); }
No ciclo() método, estamos executando o publishData () funcionar cada 5 segundos. Ele contém o código para
publicar informações sensor. o client.loop () método também nos ajuda a manter a conexão mosquitto vivo e
evita o tempo limite de conexão do corretor mosquitto.

void loop ()
{PublishData ();

atraso (5000); client.loop

(); }

Como você pode ver no seguinte trecho de código, o publishData () função obtém os valores dos sensores e publica-los
usando os rótulos tópico apropriado. Você deve ter notado que estamos usando o dtostrf () função em esta função para
alterar o formato de dados antes da publicação. o dtostrf () função é uma função fornecido pela biblioteca Arduino padrão
que converte um valor duplo em uma representação string ASCII. Também estamos adicionando um atraso de mais 5
segundos entre a publicação sucessiva de dados do sensor para evitar quaisquer problemas de buffer de dados:

vazio publishData ()
{Float humidade = getHumidity (22,0);

humidityC = dtostrf (humidade, 5, 2, message_buff2); client.publish ( "Arduino / humidade",

humidityC); atraso (5000);

movimento int = digitalRead (MotionPin);

motionC = dtostrf (movimento, 5, 2, message_buff2); client.publish ( "Arduino /
motion", motionC); }

Complete qualquer outra modificação que você deseja implementar e, em seguida, compilar o código. Se o seu código é
compilado com sucesso, você pode enviá-lo para sua placa Arduino. Se o seu mosquitto está em execução, você será capaz
ver que um novo cliente está conectado como Arduino, que é o nome do cliente que especificou no código Arduino anterior.

Desenvolver a MQTT Gateway usando mosquitto

Você pode ter o corretor running mosquitto no mesmo computador como o mosquitto Gateway, ou em
qualquer outro nó na sua rede local. Para este exercício, vamos executá-lo no mesmo computador. Abra o
arquivo de programa denominado mosquittoGateway.py para esta fase do Step2_Gateway_mosquitto pasta, que está
dentro do Exercício 4 - MQTT portal
pasta. A primeira etapa de aplicação inclui a gateway paho-MQTT programa Python base, que subscreve
o corretor mosquitto para o Arduino / humidade e
Arduino / motion tópicos:

cli.subscribe ( "Arduino / humidade", 0)

cli.subscribe ( "Arduino / motion", 0)

Quando este programa assinante MQTT recebe uma mensagem do corretor, ele chama o
onMessage () função, como já descrito no exercício de codificação anterior. Este método, em seguida,
identifica o tipo de sensor apropriado e envia os dados para o web.py
programar usando o POSTAR método. Nós estamos usando a biblioteca Python padrão, httplib, para implementar o POSTAR método
neste programa. Durante o uso da httplib biblioteca, você tem que usar o HttpConnection () método para se conectar ao
aplicativo web em execução no número de porta 8080.

Nota

Embora este programa requer que o aplicativo web (segunda etapa) deve executar em paralelo, vamos
implementar esta aplicação web na próxima seção. Certifique-se de que você primeiro executar o aplicativo web a
partir da próxima seção antes de executar este programa; caso contrário, você vai acabar com erros.

A implementação desta biblioteca requer que você primeiro importar a biblioteca em seu programa. Sendo um built-in
biblioteca, httplib não requer um processo de configuração adicional:

importar httplib

Uma vez que a conexão é estabelecida com a aplicação web, você tem de preparar os dados que precisa ser
enviado no POSTAR método. o httplib o método utiliza solicitação() método na conexão aberta para enviar os dados. Você
também pode usar o mesmo método em outras aplicações para implementar o OBTER função. Uma vez que você é
feito com o envio de dados, você pode fechar a conexão usando o fechar() método. Na implementação atual do

httplib biblioteca, estamos criando e fechar a conexão em cada mensagem. Você também pode declarar a
conexão fora do onMessage () função e fechá-lo quando você terminar o programa:

def onMessage (mosq, obj, msg):

msg.topic impressão
conexão = httplib.HTTPConnection ('10 .0.0.20: 8080' ) se msg.topic == "Arduino / motion":

data = "movimento:" + msg.payload

connection.request ( 'POST', '/ dados', os dados) postResult =
connection.getresponse () imprimir postResult

elif msg.topic == "Arduino / umidade":

data = "humidade:" + msg.payload connection.request ( 'POST', '/
dados', os dados) postResult = connection.getresponse () imprimir
postResult outra coisa: passagem

Connection.Close ()

Depois de ter realizado as modificações apropriadas, como alterar o endereço IP do corretor mosquitto eo web.py
aplicativo, vá para o próximo exercício antes de executar o código.

Estendendo o MQTT Gateway usando web.py

O código MQTT gateway fornece o interface de utilizador com a informação do sensor usando a web.py aplicativo
baseado na web. O código é bastante semelhante ao que você implementou no exercício 3. O arquivo do programa é
nomeado GatewayWebApplication.py e localizado em sua
Exercício 4 - MQTT portal pasta de código. Nesta aplicação, nós removemos o processo de seleção do sensor,
simplesmente implementando um botão, exibido como Refrescar. Esta aplicação aguarda o POSTAR mensagem
do programa anterior, que será recebido no
http: // <endereço IP>: 8080 / dados URL, em última análise, provocando a dados classe. o POSTAR
método nesta classe irá dividir a seqüência recebida para identificar e atualizar o valor do
umidade e movimento variáveis ​de sensores globais:

dados de classe:
def POST (self):
dados de movimento global, umidade i =
web.input () = web.data () data = data.split (
":") se os dados [0] == "humidade":

umidade = dados [1] elif dados [0] ==

"movimento":
movimento = dados [1] else:

return pass "Ok"

O URL padrão, http: // <ip-address>: 8080 /, exibe o base modelo com o

refrescar botão, preenchido usando o Formato() método. Como apresentado no seguinte trecho de código, o
padrão índice classe torna o modelo com o atualizado (atual) umidade
e movimento valores, quando ele recebe o OBTER ou POSTAR solicitação:

índice de classe:
submit_form = form.Form (
form.button ( 'Atualizar',
type = "submit", description = 'refresh')

)
# GET função GET def
(self):
f = self.submit_form ()
retorno render.base (f, umidade, movimento)

# função POST def

POST (self):
f = self.submit_form ()
retorno render.base (f, umidade, movimento)

Execute o programa a partir da linha de comando. Certifique-se de que você está executando ambos os programas a partir de janelas de

terminal separados.

Testando a mosquitto gateway

Você tem que seguir estes passos na ordem especificada para executar com êxito e testar todos os componentes
deste exercício:

1. Execute o corretor mosquitto.

2. Execute o cliente Arduino. Se ele estiver em execução, reiniciar o programa desligando o cliente
Arduino e ligá-la novamente.
 3. Execute o aplicativo web em seu terminal ou a partir do Prompt de Comando.
4. Execute o paho-MQTT programa Gateway.

Se você seguir essa sequência, todos os seus programas vão começar sem erros. Se você receber quaisquer erros
durante a execução, certifique-se que você siga todas as instruções corretamente, ao mesmo tempo, confirmando os
endereços IP em seus programas. Para verificar se o seu cliente Arduino MQTT, abra o Serial monitor janela no seu
Arduino IDE. Você será capaz de ver a publicação periódica das informações do sensor, como mostrado neste screenshot:

Agora, abra um navegador web em seu computador e ir para o URL da sua aplicação web. Você deve ser capaz de
ver uma janela que se parece com o que é mostrado na imagem seguinte. Você pode clicar no refrescar botão para
verificar os valores do sensor atualizados.

Nota

Criámos um atraso de 5 segundos entre as atualizações do sensor sucessivas. Daí em diante, você não será capaz de ver os
valores atualizados se você pressionar rapidamente o refrescar botão.
No terminal programa Gateway, você será capaz de ver o rótulo do tema cada vez que o programa recebe
uma nova mensagem de mosquitto. Se o atraso entre alterações sucessivas de sensores não é suficiente e httplib
não tem tempo suficiente para obter a volta resposta do web.py aplicação, o programa irá gerar uma mensagem
de erro com o
httplib função. Apesar de requerer um prazo adicional para httplib para enviar sucessivamente os dados e
receber a resposta, que será capaz de evitar esse atraso quando implementar o código Python core com
threading, evitando toda a noção de POSTAR entre os programas:

Com este exercício, você implementou dois tipos diferentes de mensagens arquitetura para transferir dados entre
o Arduino eo computador ou aplicações web usando sua rede doméstica. Embora nós recomendamos o uso de
paradigmas de hardware-centric e mensagens MQTT leve mais de arquitetura REST, você pode usar qualquer um
destes métodos de comunicação de acordo com os requisitos da aplicação.
resumo
Conectividade a redes de computadores pode realmente abrir possibilidades ilimitadas para desenvolvimento de aplicações
futuro usando Arduino. Começamos o capítulo explicando importantes fundamentos de rede de computadores, ao mesmo
tempo, cobrindo extensões de hardware que permitem que redes de computadores para Arduino. Sobre os vários métodos que
viabilizem rede, começamos o capítulo através da criação de um servidor web para Arduino. Concluiu-se que o servidor web em
Arduino não é a melhor maneira para comunicação de rede, devido ao número limitado de conexões oferecidas pelo servidor
web. Em seguida, demonstramos o uso do Arduino como um cliente web para permitir HTTP baseado em OBTER e POSTAR solicitações
de. Embora este método é útil para comunicação baseada em pedido e requer menos recursos em comparação a um servidor
web, ainda não é o melhor caminho para a comunicação do sensor devido à sobrecarga adicional de dados. Na parte posterior
do capítulo, nós descrevemos um protocolo de mensagens leve, MQTT, projetado especificamente para a comunicação sensor.
Nós demonstramos a sua superioridade para protocolos baseados em HTTP usando alguns exercícios.

Com a ajuda de cada método de comunicação Arduino Ethernet, você aprendeu sobre bibliotecas Python compatíveis
utilizados para apoiar estes métodos de comunicação. Utilizou-se o
web.py biblioteca para desenvolver um servidor web usando Python, e demonstrou o uso da biblioteca com vários
exemplos. Para suportar o protocolo MQTT, exploramos um corretor MQTT, mosquitto, e empregou a biblioteca
Python, paho_mqtt, para servir os pedidos MQTT.

No geral, nós cobrimos todos os aspectos principais de métodos de comunicação Arduino e Python ao longo deste
capítulo, e demonstrou-los com exercícios simples. Nos próximos capítulos, vamos construir sobre os princípios que você
aprendeu neste capítulo, a fim de desenvolver projetos avançados Arduino-Python que irá permitir o acesso remoto ao
nosso hardware Arduino através da Internet.
Capítulo 9. Arduino ea Internet das Coisas

No capítulo anterior, aprendemos como acessar Arduino usando Ethernet de um local remoto. O objetivo principal foi para
você começar com o desenvolvimento de aplicações de rede baseados em Arduino usando Python. Fomos capazes de
conseguir isso usando várias ferramentas, tais como a web.py biblioteca Python, mosquitto MQTT corretor, ea biblioteca
Arduino Ethernet. O acesso remoto a dados do sensor através de um Python-like linguagem extensível pode abrir
possibilidades ilimitadas para aplicações web baseadas em sensores. Nos últimos anos, o rápido crescimento destas
aplicações permitiu o desenvolvimento de um domínio chamado Internet das Coisas (IdC).

No último capítulo, nós trabalhamos em Arduino networking. No entanto, foi limitado a LAN ea premissa dos exercícios limitou-se a
sua casa ou escritório. Nós nem sequer envolvem a Internet para permitir o acesso global em nossos exercícios. aplicações
tradicionais da Internet das coisas requerem Arduino para ser acessado remotamente a partir de qualquer parte do mundo através
da Internet. Neste capítulo, vamos estender o Arduino conceitos de rede pela interface Arduino com plataformas baseadas em
nuvem. Também vamos desenvolver aplicações web para acessar os dados do sensor a partir destas plataformas em nuvem. Mais
tarde, no capítulo, vamos passar pelo processo de criação de sua plataforma de mensagens baseada em nuvem para servir dados
do sensor. No final deste capítulo, você deve ser capaz de projetar e desenvolver aplicações da Internet das coisas full-stack,
usando Arduino, Python, ea nuvem.
Começando com a Internet das coisas
Muito antes da Internet, sistemas de controle eletrônico sensor-e baseada em atuadores existia em sistemas de automação de alta
tecnologia. Nesses sistemas, os sensores foram interface com o microcontrolador através de ligações hard-wired. Devido a limitações
de capacidade de extensão, a área de cobertura destes sistemas foi geograficamente limitada. Exemplos desses sistemas de alta
tecnologia incluída automação industrial, sistemas de satélite, sistemas de armas, e assim por diante. Na maioria dos casos, os
sensores utilizados nestes sistemas eram enormes e os microcontroladores também foram limitados por suas capacidades
computacionais baixos.

Com os recentes avanços na tecnologia, especialmente na indústria de semicondutores, o tamanho físico dos sensores e
microcontroladores foi significativamente reduzida. Também tem sido possível para o fabrico de baixo custo e componentes
electrónicos altamente eficientes, por conseguinte, hoje é relativamente barato para o desenvolvimento de produtos de
hardware pequenas e eficientes baseados em sensores. Arduino e Raspberry Pi são grandes exemplos dessas conquistas.
Estes sistemas de hardware de sensores e actuadores-à base de interface com o mundo físico, que vivemos. Os sensores
medem vários elementos do meio físico, enquanto os actuadores manipular o ambiente físico. Estes tipos de sistemas
eletrônicos baseados em hardware também são conhecidos como sistemas físicos.

Na outra frente, os avanços na indústria de semicondutores também permitiu o desenvolvimento de unidades de

computação altamente eficientes, capacitando computador pessoal e indústrias de rede. Este movimento levou à
rede mundial de computadores conectados chamado CyberWorld ou da Internet. Todos os dias, petabytes de
dados são geradas e transferidas através da Internet.

O domínio da Internet das coisas está numa encruzilhada destes avanços em sistemas físicos e virtuais, onde os antigos
sistemas baseados em sensores com fio estão prontos para se atualizado para sistemas mais poderosos e eficientes que
também são altamente conectados através da Internet. Devido ao grande número de sensores envolvidos, estes sistemas de
gerar e enviar uma avalancha de dados. Os dados gerados por esses sensores já eclipsada os dados gerados por seres
humanos.

A Internet das coisas começou a se tornar um domínio significativo nos últimos anos depois de um grande número de produtos de

consumo da Internet das coisas começaram a entrar no mercado. Estes produtos incluem aplicações em automação doméstica, cuidados

de saúde, acompanhamento de atividade, energia inteligente, e assim por diante. Uma das principais razões por trás do rápido

crescimento do domínio da Internet das coisas é a introdução destas soluções visíveis. Em um grande número de casos, isso só foi

possível devido à rápida e barata de prototipagem que foi ativado por Arduino e outras plataformas de hardware de código aberto.

Até este ponto no livro, aprendemos vários métodos de interface entre os sensores e, em seguida, o desenvolvimento de aplicações
que utilizam estes sensores conectados. Neste capítulo, vamos aprender o último passo no desenvolvimento de um full-stack
Internet das coisas aplicação que permite o acesso para a sua aplicação Python-Arduino através da Internet. Agora, vamos tentar
primeiro entender a arquitetura da Internet das coisas.
Arquitetura de aplicações web da Internet das coisas
Neste livro, nós cobrimos três conceitos principais nos oito primeiros capítulos:

Camada física: Usamos vários sensores e atuadores com a placa Arduino para lidar com o ambiente físico. Os
sensores, como o sensor de temperatura, sensores de humidade, e sensor de movimento foram usadas
medido o fenómeno físico, enquanto os actuadores, tais como LEDs foram utilizados para alterar ou produzir
elementos físicos.
camada de computação: Usamos esboços Arduino e programas em Python para converter esses elementos físicos
em dados numéricos. Nós também utilizou estas linguagens de alto nível para executar várias computações tais
como cálculo de umidade relativa, o desenvolvimento de interfaces de usuário, plotagem de dados e fornecer
interfaces web.
Interface camada: Durante todo o material que coberta, nós também utilizados vários métodos de interface para
estabelecer uma comunicação entre Arduino e Python. Para a interface de parte a camada de interface entre as camadas
físicas e de cálculo, utilizou-se bibliotecas de série de portas, estabelecido com base em comunicação de rede que utiliza o
protocolo REST e MQTT, e aplicações de web desenvolvidos. Como você pode ver, temos aplicativos desenvolvidos com
firmemente acoplado física, computação e camadas de interface. No domínio da investigação, estes tipos de aplicações
também são conhecidos como sistemas cyber-físicos. Um dos termos utilizados e populares para o domínio de sistemas
ciber-físicos é a Internet das coisas. Embora o domínio de ciber-físico está completamente definido em comparação com a
Internet das coisas, a Internet das coisas recentemente ganhou mais popularidade devido ao grande número de Internet
subdomínios-industrial, dispositivos portáteis, os dispositivos conectados rede inteligente, e assim por diante, que são
abrangidos no âmbito deste termo genérico. Em termos simples, um aplicativo pode qualificar-se como uma aplicação da
Internet das coisas, se ela consiste de dispositivos de hardware que lidam com o mundo físico e tem capacidades
computacionais suficientes com ligação à Internet. Vamos tentar entender a arquitetura da Internet das coisas a partir do
material que já coberto.

No lado físico, a figura a seguir mostra os componentes de hardware que utilizamos para lidar com o ambiente físico. Os
sensores e actuadores que fazem interface com o mundo físico real podem ser ligados a Arduino utilizando vários
protocolos de baixo nível. Estes componentes podem ser ligados através de pinos GPIO e utilizando os protocolos I2C
ou SPI. Os dados adquiridos a partir desses componentes é processado na placa Arduino usando o código que é
enviado pelo usuário. Embora o código Arduino podem ser feitas auto-suficientes para executar tarefas sem quaisquer
entradas externas, estas entradas de usuários ou outras aplicações são necessárias em aplicações avançadas.
Como parte da camada de comunicação, Arduino pode ser conectado localmente para outros computadores usando USB.
Pode-se estender a faixa de cobertura, utilizando Ethernet, Wi-Fi, ou qualquer outro método de comunicação de rádio.

Tal como ilustrado na figura a seguir, os dados do sensor é recolhido utilizando unidades de computação para o processamento de
avanço. Estas unidades de computação são poderosos o suficiente para sistemas operacionais de host e plataformas de
programação. Neste livro, utilizamos Python para desenvolver vários recursos na camada de computação. A este nível, realizamos
tarefas de computação de alto nível, tais como o desenvolvimento de interfaces gráficas de usuário usando o Tkinter , traçando gráficos
biblioteca usando o matplotlib biblioteca, e em desenvolvimento de aplicações web usando o web.py biblioteca.
Em todos os exercícios de codificação que realizamos anteriormente, as áreas de cobertura físicas dos projectos
foram limitados por causa das interfaces seriais fio ou rede Ethernet local, como mostrado na figura a seguir:

Para desenvolver aplicações da Internet das coisas full-stack, precisamos acessar remotamente Arduino ou host a camada
de computação na Internet. Neste capítulo, vamos trabalhar sobre este elo perdido e desenvolver várias aplicações para
fornecer conectividade Internet para os exercícios. Para realizar esta operação, vamos utilizar uma plataforma de nuvem
comercial na primeira seção e desenvolver nossa plataforma personalizado na seção mais tarde.
Como o foco deste capítulo vai ser na conectividade nuvem, nós não estamos indo para desenvolver um circuito de hardware para
cada exercício. Vamos percorrer o exercício de design de hardware apenas uma vez e continuar usando o mesmo hardware para
todos os exercícios de programação. Da mesma forma, também vamos reutilizar o web.py programas que desenvolvemos no capítulo
anterior para se concentrar em trechos de código que estão associados com bibliotecas Python para desenvolver aplicações em
nuvem.
design de hardware
Vamos começar por desenvolver hardware padrão para todos os próximos exercícios. Vamos precisar da placa Arduino que
é anexado ao Escudo Ethernet para usar o protocolo Ethernet para conectividade de rede. Em termos de componentes, você
estará usando sensores simples e atuadores que você já utilizados nos exercícios de codificação anteriores. Vamos utilizar o
sensor de movimento de PIR e o sensor de humidade HIH-4030 para fornecer saídas digitais e analógicos, respectivamente.
Teremos também um LED como parte do projeto de hardware e isso vai ser usado na codificação exercícios como um
atuador. Para mais informações sobre as propriedades e explicações detalhadas sobre esses sensores, você pode consultar
os capítulos anteriores. Para começar a montagem dos componentes de hardware, primeiro anexar o escudo Ethernet em
cima da placa de Arduino. Ligar os sensores e actuadores para os pinos apropriados, como apresentado na figura a seguir.
Depois de ter o hardware montado, você pode conectar o escudo Ethernet para sua casa roteador usando o cabo Ethernet.
Você vai precisar para alimentar a placa utilizando o cabo USB para carregar o código Arduino do seu computador. No caso
de você deseja implantar a placa Arduino para um local remoto, você vai precisar de uma fonte de 5V externo para poder
Arduino.
As plataformas de Internet das coisas nuvem
O termo plataforma de Internet das coisas nuvem é usado para as plataformas em nuvem que oferecem serviços muito específicos,

suporte de protocolo e ferramentas baseadas na Web para aplicações da Internet das coisas. Em termos mais informais, essas

plataformas em nuvem da Internet das coisas pode ser usado para carregar os seus dados de sensores e acessá-los de qualquer lugar

usando a Internet. Com essas características básicas, elas também fornecem ferramentas para acessar, visualizar e processar os seus

dados de sensores em diversas plataformas, como computadores e smartphones. Exemplos de plataformas IdC nuvem semelhantes

incluem Xively ( http://www.xively.com ), 2lemetry ( http://www.2lemetry.com ), Carriots ( http://www.carriots.com ), ThingSpeak ( http://thingspeak.com

), e assim por diante. Os seguintes figura mostra a arquitectura de um sistema IdC com um sistema de sensores com base em Arduino

que está a enviar dados para uma plataforma de nuvem, enquanto uma unidade de cálculo está a aceder aos dados remotamente a

partir da nuvem;

Xively, sendo a plataforma mais antigo e mais popular da Internet das coisas, tem uma grande quantidade de ajuda comunitária online
baseado que está disponível para iniciantes. Esta é uma das principais razões pelas quais nós escolhemos Xively como nossa
plataforma de escolha para os próximos exercícios. Recentemente, Xively mudou sua política de criação de contas de
desenvolvedores livres e um usuário tem de solicitar o acesso a esta conta gratuita em vez de obter um livremente. No caso de você
querer usar outra plataforma que não seja Xively, nós cobrimos brevemente algumas plataformas semelhantes no final desta seção.
Xively - uma plataforma de nuvem para a Internet das coisas
Xively é uma das primeiras plataformas de nuvem específicas do Internet das coisas que foi fundada em 2007 como Pachube. Ele passou

por várias mudanças de nome, como era chamado Cosm, mas é atualmente conhecida como Xively. Xively fornece uma plataforma de

Internet das coisas nuvem com ferramentas e serviços para desenvolver dispositivos conectados, produtos e soluções. Como mencionado

em seu site, Xively é a nuvem pública que é construído especificamente para a Internet das coisas.

A criação de uma conta no Xively

Agora, podemos ir em frente e criar uma nova conta de usuário para a plataforma Xively. Para configurar uma conta, você precisa
executar os seguintes passos na ordem indicada:

1. Para começar o processo de inscrição on Xively.com , aberto https://xively.com/signup em um web

navegador.

2. Na página de inscrição, você será solicitado a selecionar o nome de usuário ea senha, como mostrado na
imagem seguinte:

3. Na página seguinte, você será solicitado a inserir algumas informações adicionais que inclui o seu nome completo, nome
da organização, país, código postal, fuso horário, e assim por diante. Preencha o formulário de forma adequada e
clique no Inscrever-se botão:
 4. Xively vai enviar uma ativação por e-mail para a conta de e-mail que você especificou no formulário. Abra o e-mail e
clique no link de ativação. Verifique sua pasta de spam se você não vir o e-mail na sua caixa de entrada.

5. Depois de clicar no link de ativação, você será redirecionado para a página de boas-vindas no site da Xively.
Aconselhamo-lo a percorrer os tutoriais fornecidas na página de boas-vindas, uma vez que irá ajudá-lo a se
familiarizar com a plataforma Xively.
6. Depois de completar os tutoriais, você pode voltar para a tela principal do usuário a partir da página usando o https://xively.com/lo
ligação.

Se você ainda não estiver logado, você vai exigir o seu endereço de e-mail como nome de usuário e uma senha
apropriada para entrar no plataforma Xively.

Trabalhando com Xively

A plataforma Xively permite criar instâncias do dispositivo em nuvem que podem ser conectados ao actual dispositivo de
hardware, aplicativo ou serviço. Execute os seguintes passos a fim de trabalhar com Xively:

1. Para começar a trabalhar com a plataforma Xively, adicionar um dispositivo a partir da página principal, como
 exibido na imagem seguinte:

2. Uma vez que você clicar no Adicionar Dispositivo botão, ele irá pedir-lhe para o seguinte
janela onde você será solicitado a fornecer o nome do dispositivo, a descrição e status de privacidade do dispositivo que você

está indo para atribuir. No formulário, selecione o nome do dispositivo que você deseja que o dispositivo de desenvolvimento a

ser chamado, fornecer uma descrição breve, e selecione dispositivo privada como o status de privacidade:
3. Uma vez que você clicar no Adicionar Dispositivo botão, Xively irá criar uma instância dispositivo com

parâmetros e pedir-lhe para o ambiente de desenvolvimento bancada gerado automaticamente. Na página do

dispositivo que acabou de adicionar, você pode ver vários parâmetros de identificação e segurança, tais como ID do
produto, número de série, alimentação ID: Apascenta URL, e API Endpoint. De entre estes parâmetros, você
freqüentemente precisa do ID alimentação informações para os próximos exercícios:

4. A chave de API única e segura do dispositivo recém-criado também está localizado na barra lateral do lado direito da
página. Esta chave de API é muito importante e precisa ser protegido como sua senha, como qualquer pessoa com a
chave de API pode acessar o dispositivo.
5. Agora, para acessar remotamente o dispositivo, abra o terminal e use o comando cURL para enviar
dados a ele. No comando a seguir, altere o < Your_Feed_ID> e
<YOUR_API_KEY> valores com os disponíveis para o seu dispositivo:

$ Onda PUT --request --data "0,10" --header "X-apiKey: <YOUR_API_KEY"

https://api.xively.com/v2/feeds/<Your_Feed_ID>.csv

6. Como você pode ver, o comando anterior enviou o valor de 10 no canal 0 de seu dispositivo em Xively.
Depois de executar o comando anterior, você vai notar que o Xively bancada é atualizado com as
informações que você acabou de enviar usando cURL:

7. Tente enviar vários valores no canal 0 usando o comando anterior. Na bancada Xively, você será capaz
de ver um ser trama gerada por esses valores em tempo real. Acesse o enredo clicando no canal 0 no
ambiente de trabalho:
Usando o método que usamos neste exemplo, também podemos configurar Arduino para enviar valores do sensor
automaticamente para a plataforma Xively. Isto irá permitir o armazenamento e visualização de dados Arduino em Xively.
plataformas da Internet das coisas alternativa
Nesta seção, nós fornecemos links importantes para as plataformas ThingSpeak e Carriots. Como não estão cobrindo
essas plataformas em detalhe, esses links irá ajudá-lo para encontrar exemplos semelhantes para fazer a interface
Arduino e Python com ThingSpeak e Carriots.

ThingSpeak

Os tutoriais em links a seguir irão ajudá-lo a se familiarizar com a plataforma ThingSpeak se você optar
por usá-lo em vez de Xively:

O site oficial: https://thingspeak.com/

Usando Arduino e Ethernet para atualizar um canal ThingSpeak:
http://community.thingspeak.com/tutorials/arduino/using-an-arduino-ethernet-shield--a actualização
de-um-thingspeak-canal /
exemplos Arduino para ThingSpeak: https://github.com/iobridge/ThingSpeak- Arduino Exemplos

Comunicando-se com ThingSpeak usando Python:

http://www.australianrobotics.com.au/news/how-to-talk-to-thingspeak-with-python- uma memória-cpu
monitores
Usando Arduino e Python para falar com um canal ThingSpeak:
http://vimeo.com/19064691
Série de tutoriais ThingSpeak: http://community.thingspeak.com/tutorials/

ThingSpeak é uma plataforma open source e você pode criar sua própria versão personalizada do ThingSpeak
usando os arquivos fornecidos. Você pode obter esses arquivos e a diretriz associada de https://github.com/iobridge/ThingSpea
.

Carriots
Carriots também fornece, uma conta básica gratuita para desenvolvedores. Se você quiser usar Carriots como uma alternativa
para Xively, use os tutoriais nas seguintes links para começar:

O site oficial: https://www.carriots.com/

A criação de uma conta no Carriots: https://learn.adafruit.com/wireless-gardening-
arduino-CC3000-WIFI-modules / definindo-up-your-carriots-conta
A biblioteca Carriots para Arduino: https://github.com/carriots/arduino_library
A Carriots exemplo para Arduino: https://github.com/carriots/arduino_examples
Ligue Carriots para a aplicação web Python:
http://www.instructables.com/id/Connect-your-Carriots-Device-to-Panics-Status-Boa/
Desenvolvimento de aplicações de nuvem usando

Python e Xively
Agora, você tem uma idéia básica sobre as plataformas da Internet das coisas comerciais disponíveis e você pode selecionar
um de acordo com seu nível e requisitos de conforto. Vai ser muito difícil abrangente explicar cada plataforma de nuvem com
exemplos práticos, como o objetivo deste capítulo é torná-lo familiarizado com a integração da plataforma de nuvem com
Python e Arduino. Por esta razão, estamos indo para usar Xively como o de facto plataforma de Internet das coisas nuvem para
o resto dos exercícios de integração.

Agora que você sabe como criar uma conta no Xively e trabalhar com a plataforma Xively, é hora de começar a
interface hardware real com a plataforma Xively. Nesta seção, vamos passar por métodos de upload e download
de dados de Xively. Vamos combinar o hardware Arduino que construímos com os programas em Python para
mostrar-lhe métodos básicos de comunicação com Xively.
Interface Arduino com Xively
A primeira etapa para estabelecer a comunicação com a interface Xively inclui a placa Arduino com a plataforma
Xively via independente Arduino código. Nós já construiu o hardware necessário usando o Arduino Uno, Escudo
Ethernet, e alguns sensores. Vamos ligá-lo ao computador através da porta USB. Você também precisa conectar
o protetor de Ethernet para sua casa roteador usando o cabo Ethernet.

Upload Arduino dados para Xively

O Arduino IDE tem um exemplo built-in que pode ser usado para se comunicar com o serviço Xively. Isto é conhecido
como PachubeClient ( Pachube era o nome anterior do Xively).

Nota

É importante notar que a razão por trás usando este exemplo padrão é dar-lhe um jump-start nos exercícios de
interface. Este esboço particular é bastante antigo e pode obter caiu como um exercício padrão nas próximas versões
do Arduino IDE. Nesse caso, você pode saltar directamente para o próximo exercício ou desenvolver o seu esboço
personalizado para executar o mesmo exercício.

Execute os seguintes passos para carregar Arduino dados para Xively:

1. Abra o Arduino IDE e, em seguida, aberta PachubeClient exemplo por navegar para
arquivo | Exemplos | Ethernet | PachubeClient.
2. Para estabelecer comunicação com Xively, você vai precisar do ID alimentação e a chave de API do seu
dispositivo Xively, que você obteve na última seção.
3. No esboço Arduino aberto, executar as seguintes alterações utilizando o ID de ração obtido e chave de API. Você pode
especificar qualquer nome de projeto para o AGENTE DE USUÁRIO parâmetro:

# definir apiKey "<Your-API-key>"

# definir feedId <Your-feed-ID>
# definir USERAGENT "<Your-project-name>"

4. No esboço Arduino, você também terá que alterar o endereço MAC eo endereço IP do seu escudo Ethernet.
Você deve estar familiarizado com a obtenção desses endereços a partir do exercício que você realizou
no capítulo anterior. Usar estes valores e modificar as seguintes linhas de código apropriadamente:

byte mac [] = {0x90, 0xA2, 0xDA, 0x0D, 0x3F, 0x62}; IPAddress ip (10,0,0,75);

5. Como o exemplo Arduino aberto foi criado para o Pachube, é necessário atualizar o endereço do servidor para api.xively.com
como especificado no seguinte fragmento de código. Comente a linha de endereço IP como nós não vai precisar
dele mais e adicione o servidor[]
parâmetro:

// servidor IPAddress (216,52,233,122); servidor char [] =

"api.xively.com";

6. No sendData () função, alterar o nome do canal de HumidityRaw como nós temos o nosso
HIH-4030 sensor de humidade ligado à porta analógica. Nós não estão realizando qualquer
 cálculos de umidade relativa a esta fase e estão indo para carregar apenas os dados brutos do sensor:

// aqui está o verdadeiro conteúdo do pedido PUT: client.print ( "HumidityRaw");

client.println (thisData);

7. Depois de ter realizado essas mudanças, abrir o XivelyClientBasic.ino arquivo

a pasta que contém os códigos para este capítulo. Compará-los com o seu desenho atual e compilar /
carregar o esboço para a placa Arduino, se tudo parece satisfatório. Depois de ter carregado o código,
abra o Serial monitor janela no Arduino IDE para observar o seguinte resultado:

8. Se você vê uma saída na Serial monitor janela que é semelhante ao

exibido na captura de tela anterior, o Arduino está conectado com sucesso para Xively e está a
transferir dados no canal HumidityRaw.
9. Abra o seu dispositivo no site da Xively e você será capaz de ver uma saída que é semelhante à imagem seguinte
na página da web. Isso confirma que você enviou com sucesso dados para uma plataforma de Internet das coisas
nuvem usando a sua localizada remotamente Arduino:
Transferência de dados para Arduino de Xively

No exercício de codificação anterior, foi utilizado um exemplo Arduino padrão para se comunicar com Xively. No
entanto, Xively também fornece uma biblioteca Arduino muito eficiente com built-in funções para a programação rápida.
No próximo exercício, vamos utilizar um método alternativo para se comunicar com a plataforma Xively usando o Xively-Arduino
biblioteca. Embora você possa usar um desses métodos, recomendamos que você use o Xively-Arduino biblioteca como é
oficialmente mantida por Xively.

Neste exercício, vamos baixar valores digitais a partir de um canal chamado LED. Mais tarde, vamos usar esses
valores digitais, 0 e 1, para mudar um LED que está ligado a nossa placa de Arduino. Como uma entrada para
esse canal, que irá alterar o valor atual do canal no site da plataforma Xively, deixando o download Arduino esse
valor e executar a tarefa apropriada.

Vamos começar por importar o Xively-Arduino biblioteca e suas dependências. Como você já sabe como importar
bibliotecas na Arduino IDE, visita
https://github.com/amcewen/HttpClient Para baixar e importação do HttpClient biblioteca. Esta é uma dependência que

é exigido pelo Xively-Arduino biblioteca a função. Depois de importar o HttpClient biblioteca, baixar o Xively-Arduino biblioteca a

partir de https://github.com/xively/xively_arduino e repita o processo de importação. o Xively-Arduino navios da biblioteca

com alguns exemplos para que você possa começar. Nós vamos usar o seu exemplo como código base para o

download de dados para o nosso exercício.

1. No IDE Arduino, para navegar arquivo | Exemplos | Xively_arduino |

DatastreamDownload e abra a DatastreamDownload exemplo. Alterar a chave API padrão para sua
própria chave de API que foi obtida a partir do dispositivo que você criou. Como apresentado no seguinte
trecho de código, é preciso também identificar o nome do canal, que é liderado neste caso:

Char xivelyKey [] = "<Your-API-key>";

 caractere ledId [] = "LED";

2. A Xively-Arduino biblioteca requer que você defina o XivelyDatastream variável

como uma matriz. Você também pode especificar múltiplos fluxos de dados de acordo com a sua aplicação:

os fluxos de dados XivelyDatastream [] = {

XivelyDatastream (ledId, strlen (ledId), DATASTREAM_FLOAT),};

3. Você também precisa declarar uma variável chamada alimentação usando o XivelyFeed função. Como
exibidos na seguinte linha de código, substituir o ID de alimentação padrão com o apropriado.
Na inicialização do alimentação variável, o valor 1 representa o número de datastreams no XivelyDatastream matriz:

alimentação XivelyFeed (<Your-feed-ID>, fluxos de dados, 1);

4. No nosso exercício, queremos recuperar periodicamente o valor do canal de LED e virar o LED real ligado
ou desligado em conformidade. No seguinte trecho de código, obtém-se o valor float da ração [0], Onde 0 especifica
os dados de fluxo localizado no 0
posição datastreams matriz:

Serial.print ( "valor LED é:"); Serial.println (alimentação [0]

.getFloat ());

se (alimentação [0] .getFloat ()> = 1) {

digitalWrite (ledPin, ALTA); } outro{

digitalWrite (ledPin, LOW); }

5. Como você sabe agora que os parâmetros precisam ser alteradas para este exercício, abra o
XivelyLibBasicRetrieveData.ino esboço Arduino da pasta de código. Este esboço contém o código exato que você
precisa usar para o exercício. Embora este esboço inclui as modificações necessárias, você ainda vai ter que
mudar os valores para os parâmetros específicos da conta, ou seja, a chave de API, ID alimentação, e assim por
diante. Antes de ir em frente e carregar este esboço, ir para a plataforma Xively e criar um canal chamado

CONDUZIU com Valor atual Como 1, como exibido na imagem seguinte:

 6. Agora, compilar e fazer o upload do código ao seu Arduino.
7. Depois de ter carregado o código compilado para o Arduino, abra o Serial
Monitor janela e esperar por uma saída que é semelhante ao exibido na imagem seguinte.
Você vai notar que o LED no hardware Arduino está ligado:

8. Você pode voltar para o canal de LED Xively e mudar o Valor atual campo para
0. Dentro de poucos segundos, você vai notar que o LED no hardware Arduino é desligado. Com
este exercício, você estabeleceu com sucesso a comunicação de duas vias entre Arduino ea
plataforma Xively.

código avançado para upload e download de dados usando Arduino

Nos dois exercícios anteriores Arduino, foi realizada individualmente o upload e download de tarefas. Neste
exercício, queremos criar um programa Arduino onde pudermos
enviar os dados dos sensores ligados (o sensor de movimento de PIR e o sensor de humidade HIH-4030) durante a
recuperação do valor para controlar o LED. Abra o esboço Arduino,
XivelyLibAdvance.ino, que contém o código que demonstra ambas as funcionalidades. Como você pode
ver no seguinte trecho de código, definimos três canais separados para cada componente,
enquanto o independente XivelyDatastream
objetos para upload ( datastreaU []) e download ( datastreamD []). Da mesma forma, também criamos dois feeds
diferentes, feedU e feedD. A principal razão por trás de delegar as tarefas de upload e download de objetos
diferentes é atualizar independentemente do valor do canal de LED ao carregar o fluxo de dados para os
canais, HumidityRaw e MotionRaw: char ledId [] = "LED";

caractere humidityId [] = "HumidityRaw"; caractere pirId [] =

"MotionRaw";

int ledPin = 2; int pirPin =

3;

XivelyDatastream datastreamU [] = {
XivelyDatastream (humidityId, strlen (humidityId), DATASTREAM_FLOAT), XivelyDatastream (pirId, strlen (pirId),
DATASTREAM_FLOAT),};

XivelyDatastream datastreamD [] = {
XivelyDatastream (ledId, strlen (ledId), DATASTREAM_FLOAT),};

XivelyFeed feedU (<Your-feed-ID>, datastreamU, 2); XivelyFeed feedD

(<Your-feed-ID>, datastreamD, 1);

No ciclo() função do código Arduino, que periodicamente buscar o valor corrente do canal de LED feedD e,
em seguida, executar a ação LED:

int Retd = xivelyclient.get (feedD, xivelyKey); Serial.print ( "xivelyclient.get

voltou");

Na segunda fase da função periódica, obtém-se os valores dos sensores a partir de matérias-o
análogo e pinos digitais da placa Arduino e, em seguida, carregar esses valores usando feedU: int
humidityValue = analogRead (A0); datastreamU [0] .setFloat (humidityValue); int pirValue = digitalRead (pirPin); datastreamU [1]
.setFloat (pirValue);

int retu = xivelyclient.put (feedU, xivelyKey); Serial.print ( "xivelyclient.put voltou");

Faça as alterações apropriadas no código para acomodar ID alimentação e chave de API e, em seguida, fazer o upload
do esboço para a placa Arduino. Uma vez que você carregar este esboço Arduino para sua plataforma, você deve ser
capaz de ver o seguinte resultado na Serial monitor janela. Agora você pode desconectar o Arduino da porta USB e
conecte a fonte de alimentação externa. Agora que você conectou o Arduino montagem para sua rede local usando um
cabo Ethernet, você pode colocar o Arduino montagem em qualquer local em seu local de trabalho.
a transferir dados para Xively - Python
Semelhante à forma como nós interface Arduino para Xively, vamos agora explorar métodos para conectar a plataforma
Xively via Python e, assim, completar o ciclo. Nesta seção, vamos nos concentrar em maneiras diferentes de transferir dados
para Xively usando Python. Vamos começar com um método básico de comunicar com Xively e estendê-la ainda mais com web.py
para implementar a interface usando um aplicativo web.

Para começar, vamos primeiro instalar biblioteca Python de Xively, xively-pitão, no seu computador usando o seguinte
comando:

$ Pip sudo instalar xively-python

O método básico para enviar dados

Mais uma vez, você vai precisar da chave de API e ID alimentação do seu dispositivo virtual que você criou na plataforma
Xively. Python, assistida pelo xively-pitão biblioteca, fornece métodos muito simples para estabelecer um canal de
comunicação com a plataforma Xively. A partir da pasta de código, a céu aberto uploadBasicXively.py Arquivo. Conforme
especificado no código, substitua o FEED_ID e CHAVE API variáveis ​com o ID alimentação adequada e chave de API:

FEED_ID = "<Your-feed-ID>" API_KEY =

"<-chave Your-API>"

usando o XivelyAPIClient método, criar um api exemplo e criar a alimentação variável usando o api.feeds.get () método:

API = xively.XivelyAPIClient (API_KEY) alimentação =

api.feeds.get (FEED_ID)

Assim como fizemos nos exercícios Arduino, você vai precisar para criar fluxos de dados para cada canal a partir dos feeds.
Conforme especificado no seguinte trecho de código, para tentar obter o canal especificado a partir da alimentação ou criar um se
ele não estiver presente no dispositivo virtual Xively. Você também pode especificar as tags e outras variáveis ​ao criar um novo
canal:

experimentar:

datastream = feed.datastreams.get ( "Random"), exceto httpError como e:

imprimir "httpError ({0}): {1}". formato (e.errno, e.strerror) datastream = feed.datastreams.create ( "Random",
as tags = "python") print "Criando fluxo de dados" aleatório"

Depois de ter aberto o fluxo de dados para um canal, você pode especificar o valor atual usando o datastream.cuurent
método e atualizar o valor, que irá carregar este valor ao canal especificado:

datastream.current_value = randomValue datastream.at =

datetime.datetime.utcnow () datastream.update ()

Depois de ter realizado as modificações especificadas para o uploadBasicXively.py arquivo, executá-lo usando o
seguinte comando:
$ Python uploadBasicXively.py

Abra o seu dispositivo virtual no site da Xively para encontrar o Aleatória canalizar preenchida com os dados que
você enviou. Ele será semelhante à imagem a seguir:

Upload de dados usando uma interface web baseada em web.py

No capítulo anterior, nós trabalhamos com o web.py enquanto biblioteca de desenvolvimento de modelos e aplicações
web. Neste exercício, vamos utilizar um dos programas em que criou o web.py formulários com o código Xively que
desenvolvemos no exercício anterior. O objetivo deste exercício é para enviar dados para o canal de LED usando um
aplicativo web enquanto observa o comportamento do LED no hardware Arduino.

Você pode encontrar o programa Python para este exercício na pasta deste capítulo com o nome
uploadWebpyXively.py. Como você pode ver no código, estamos usando o web.py forma a obter duas
entradas, Canal e Valor. Usaremos essas entradas para modificar o valor atual do canal de LED:

submit_form = form.Form (
form.Textbox ( 'Canal', description = 'Canal'), form.Textbox ( 'Valor', description = 'valor'), form.button (
'enviar', type = "submit", description = 'enviar')

O arquivo de modelo, base.html, também é modificado para acomodar pequenas alterações que são exigidos por este
exercício. Como você pode ver no arquivo Python aberto, estamos usando o mesmo código que usamos para fazer a
interface com Xively no exercício anterior. A única grande modificação é feito para o datastream.update () método, que agora
é colocado no
POSTAR() função. Este método será executado quando você enviar o formulário. Uma vez que você alterar a chave de API e
ID alimentação neste arquivo, executar o código Python e aberto
http: // localhost: 8080 no seu navegador web. Você pode ver o aplicativo em execução web, como mostrado na
imagem seguinte. Insira o valor como mostrado na figura para ligar o LED na placa Arduino. Você pode
alterar a Valor parâmetro para 0 para desligar o LED.