A lista de componentes

No capítulo anterior, nós só usamos um LED para a programação usando Arduino, um cabo USB Arduino, e um
computador. O principal componente de hardware necessário para este projeto é um sensor PIR movimento. Você
também vai precisar de um LED adicional. Recomendamos que você tem um LED de cor diferente do que o que você já
tem. A descrição das componentes necessárias é como se segue:

sensores PIR: Estes são amplamente utilizados como sensores de detecção de movimento para projetos de DIY.
Eles são pequenos, baratos, consomem menos energia e são compatíveis com as plataformas de hardware, como
Arduino. Um sensor de PIR usa um par de sensores piroeléctricos que detectam a radiação infravermelha. Se não
houver movimento, a saída destes sensores cancela um ao outro. Qualquer movimento no ambiente irá produzir
diferentes níveis de radiação infravermelha por estes sensores piroeléctricos e a diferença será desencadeada uma
saída que é HIGH (+ 5 volts). Nós estaremos usando o sensor PIR que é vendido por SparkFun, e você pode obtê-lo de https://ww
. O sensor de PIR vem equipado com a placa de circuito impresso requerido (PCB). Ele tem uma gama de até 20
pés (6 metros), o que é suficiente para o projecto. A imagem seguinte mostra o Sensor PIR disponíveis no site da
SparkFun:

Fonte: Sparkfun Inc.

LEDs: Recomendamos que você use LEDs verdes e vermelhos para o projeto. Se eles não estiverem disponíveis, você pode

usar quaisquer dois LEDs com cores diferentes.

Fios, resistores e da placa de ensaio: Você vai precisar de um monte de fios e uma placa de ensaio para
completar as ligações. Como prática, ter pelo menos três cores diferentes de conectores de fio para
representar o poder, chão, e sinal. Você também vai precisar de dois 220 ohm e um 10 resistores pull kilo-ohm.
A placa Arduino: A placa Arduino Uno é suficiente para as necessidades do projeto. Você também pode usar
Arduino mega ou qualquer outra placa Arduino para este projeto. O projeto requer apenas três I / O pins e
qualquer placa Arduino disponível está equipado com mais de três I / O pins.

Um cabo USB: Você vai precisar de um cabo USB para carregar o código Arduino e realizar a comunicação
serial com a placa de Arduino.
Um computador: Nós já configurou um computador com Python eo Arduino IDE para seu sistema
operacional favorito nos capítulos anteriores. Você vai precisar deste computador para o projeto. Certifique-se
de que você tem todos os componentes de software que instalados e configurados nos capítulos anteriores.
O design de fluxo de software
O primeiro passo, antes de saltar para trabalhar em qualquer sistema de hardware, é projetar o fluxo de projeto usando
a lógica. Recomendamos que você tem seu projeto esboçado como um fluxograma para entender melhor o layout dos
componentes e o fluxo do código. O diagrama a seguir mostra o fluxo do projeto, onde você pode ver que o projeto é
executado em ciclos uma vez o movimento é detectado e as ações apropriadas LED são realizadas:

Como você pode ver, a lógica do programa começa por detectar o estado do sensor PIR e executa as ações apropriadas em
conformidade. Com uma única instrução Arduino, você só pode transformar o LED ligado ou desligado. Para executar a
operação intermitente, teremos de realizar repetidamente a transformar-on e transformando-off ações com um atraso de
tempo entre as ações. Também irá inserir um atraso entre a execução de cada ciclo sucessivo de modo que a saída do
sensor de PIR pode estabelecer-se. Note que vamos usar o mesmo fluxo ao escrever o código para ambos os métodos de
programação.
O projeto do sistema de hardware
Projetando um diagrama para o seu fluxo de software ajuda você a escrever o programa e também auxilia na identificação
de ações e eventos para o projeto. O processo de concepção do sistema de hardware inclui as conexões do circuito,
desenho esquemático, de simulação, de verificação, e testes. Este processo de design fornece uma compreensão
detalhada do projeto e os componentes de hardware. Ele também ajuda na verificação preliminar e teste do projeto de
arquitetura. Antes de saltar para o processo de design de hardware deste projeto, vamos nos familiarizar com as
ferramentas úteis.

Apresentando Fritzing - um software de hardware prototipagem

Você não é obrigado a projetar o sistema de hardware para este projeto. Em geral, neste livro, serão fornecidos os
projetos de sistemas de hardware, como o foco principal do livro é sobre a programação ao invés de design de
hardware.

Se você está interessado em design de sistema ou prototipagem rápida dos componentes de hardware, a ferramenta de software
de código aberto utilizado para este fim é chamado Fritzing. Os esquemas para seus projetos podem ser projetados usando
Fritzing e pode ser obtido a partir
http://fritzing.org/download/ .

Fritzing é uma iniciativa de software de automação de design eletrônico suportada pela comunidade para designers, artistas e

amadores. Ele permite que você converter seu esboço hardware do papel para software como um diagrama de circuito.

Fritzing também fornece uma ferramenta para criar layouts PCB de seus projetos. Fritzing extensivamente suporta Arduino e

outras plataformas de hardware DIY de código aberto populares. Você pode explorar Fritzing via exemplos de projetos built-in.

Instalar e executar Fritzing. O seguinte mostra um dos projetos padrão que são exibidas após Fritzing abertura captura de tela:
Como você pode ver, uma caixa de ferramentas contendo componentes de hardware virtual está localizado à direita da janela
aberta. O principal espaço de edição, localizado no centro, permite que o usuário arraste e soltar componentes da caixa de
ferramentas e também permite que o usuário conexões completas entre esses componentes. Você pode aprender mais sobre os
recursos fornecidos pelo Fritzing e passar por algumas hands-on tutoriais em http://fritzing.org/learning/ .

Trabalhando com a placa de ensaio

Quando estiver familiarizado com Fritzing, você tem a flexibilidade para criar seus próprios circuitos, ou você pode
sempre usar os arquivos Fritzing fornecidos com o livro. No entanto, há um outro desafio, que é, portando seu circuito
virtual para um físico. Um dos componentes fundamentais utilizados pelos projetos eletrônicos que permitem
implementar conexões e construir o circuito físico que é o breadboard.

A placa de ensaio contém linhas de metal inteligentemente organizados escondidos sob uma montagem contendo
orifícios de plástico. Este conjunto ajuda o usuário a fios de conexão sem passar por qualquer trabalho de solda. É
realmente fácil de inserir e remover fios ou componentes eletrônicos através dos furos. A figura seguinte mostra uma
pequena placa de ensaio com um par de componentes e algumas conexões de fios:
Nota

Saiba mais sobre breadboards e os tutoriais para usá-los em

http://learn.sparkfun.com/tutorials/how-to-use-a-breadboard .

A placa de ensaio principalmente tem dois tipos de tiras de conexão: tiras de terminais e trilhos de alimentação. Tal como
apresentado na figura anterior, tiras terminais são colunas verticais com furos em curto-circuito eléctrico. Em palavras simples,
uma vez que você conectar qualquer componente de uma das tiras de terminais, o componente será eletricamente conectada a
cada buraco na coluna. As colunas de tiras terminais são separadas pela Dual in-line Package (DIP) lacuna apoio. (DIP é um
invólucro comum para componentes electrónicos.) Na mesma coluna, tiras terminais acima e abaixo do intervalo de suporte DIP
estão electricamente independente. Enquanto isso, os trilhos de alimentação estão em curto horizontalmente ao longo de toda a
linha da placa de ensaio. Os trilhos de alimentação são usados ​principalmente para conectar conexões positivas e de terra da
fonte de alimentação, para que ele possa ser distribuído facilmente a todos os componentes.

Nota

História da breadboards

Nos primeiros anos de eletrônica, as pessoas costumavam breadboards reais (que foram usados ​para pão corte) para
conectar seus componentes grandes com pregos apenas e fios. Uma vez que os componentes eletrônicos começou a ficar
menor, a placa de montar circuitos também se tornou melhor. O termo preso por esta evolução, e nós ainda chamar as placas
modernas breadboards. Se você está interessado, você pode conferir http://www.instructables.com/id/Use-a-real-Bread-
Board-para-prototipagem-your-circui / , Que proporciona instruções para montar um circuito utilizando as tábuas de pão
originais.

Projetando o protótipo de hardware

É hora de recolher os componentes de hardware mencionado anteriormente e começar a construir o sistema. A
figura próximos mostra o circuito para o projeto que foi desenvolvido usando Fritzing. Se você tem experiência de
trabalho com o circuito de montagem, vá em frente e ligue os componentes como mostrado na figura:

Se esta é sua primeira experiência de trabalhar com sensores e a placa de ensaio, utilize os seguintes passos para
completar o circuito de montagem:

1. Ligação VCC (+ 5V) e a massa do Arduino para a placa de ensaio.

2. Ligar o ânodo (ligação longa) do LED vermelho para o pino 12 digitais da placa Arduino. Conecte o cátodo
(curta chumbo) do LED vermelho a terra com 220 ohm resistores.
3. Ligar o ânodo (ligação longa) do diodo emissor de luz verde ao pino digital 13 da placa Arduino. Conecte o
cátodo (curta chumbo) do LED verde para a terra com 220 ohm resistores.

4. Ligue VDD do sensor PIR para VCC na placa de ensaio. Usar a mesma cor fio para representar a mesma
categoria de conexões. Isso vai ajudar muito na solução de problemas do circuito.

5. Ligue o sinal (pino central) do sensor de PIR para Arduino pino digital 7 com uma resistência pull-up de 10
quilo-ohm.

A maioria dos especialistas preferem um diagrama esquemático em vez do diagrama protótipo que usamos anteriormente.
diagramas esquemáticos são úteis quando você estiver usando componentes compatíveis em vez dos componentes exatos do
diagrama de protótipo. O seguinte é um diagrama esquemático do circuito de produtos eletrônicos que nós projetamos mais cedo.
Este diagrama está
também obtido usando Fritzing:

Seu sistema agora está pronto para executar o programa Arduino. Como vamos estar usando o mesmo hardware para ambos os
métodos de programação, você está quase terminando de trabalho com a eletrônica, a menos que você encontrar um problema. Só
para ter certeza que tudo está conectado perfeitamente, cheque deixou escapar essas conexões na próxima seção.

Nota

Note-se que resistores pull-up são usados ​para se certificar de que o sinal de saída de um transe sensores PIR no nível
lógico esperado.
conexões de hardware de teste
Uma vez que as conexões do circuito estão completas, você pode ir diretamente para as seções de programação. Como
uma prática recomendada, recomendamos que você verifique as conexões do circuito e verifique o status do sensor.
Estamos assumindo que sua placa Arduino já está equipado com o StandardFirmata esboçar que discutimos no capítulo
anterior. Caso contrário, consulte o capítulo anterior e fazer o upload do StandardFirmata esboçar a sua placa Arduino.

A melhor maneira de verificar a nossa implementação circuito é usar o programa de teste Firmata que usamos no
capítulo anterior. De acordo com a configuração do projeto, o sensor PIR fornece entradas de eventos para Arduino pino
7. No programa de teste, altere o tipo de pin 7 a Entrada e acenar com a mão sobre o sensor, e você deve ser capaz de
ver o estado do pino como
Alto, como exibido na imagem seguinte:

Verifique as conexões de LED através da criação de pinos 12 e 13 como pinos de saída e alternando o
botões para definir o status dos pinos. Se você ver os LEDs piscando enquanto você está alternando o botão, em seguida, as
conexões estão funcionando perfeitamente.

Se você não pode executar com sucesso nestas verificações, verificar e repetir as etapas do projeto.
Método 1 - usando um autônomo esboço Arduino

Como discutimos nos capítulos anteriores, um projeto pode ser implementado através da criação de código Arduino nativa

específica do projeto ou usando uma abordagem híbrida Python em Arduino. Os esboços Arduino nativas são úteis em

aplicações onde é necessário insignificante ou nenhuma comunicação com um sistema de computador. Embora este tipo de

projeto autônomo permite a operação contínua na ausência de conectividade serial, é difícil manter a actualização e upload

um esboço Arduino para pequenas modificações. Se você olhar para as várias aplicações deste projeto, você vai notar que

apenas alguns deles exigem que o projeto seja implementado como um sistema autônomo que apenas detecta movimento e

pisca LEDs. Este tipo de sistema pode ser facilmente implementado por um esboço Arduino simples.
A configuração do projeto
Antes de ir adiante com o projeto, certifique-se de que você tem as seguintes coisas no lugar:

Os componentes de hardware são configurados e estão funcionando corretamente seu Arduino

é conectada ao computador através de um cabo USB
O computador tem o Arduino IDE e você pode acessar a placa Arduino conectado através do IDE
O esboço Arduino
Esta seção descreve o código Arduino para o projeto. Antes de entrar em uma descrição passo-a-passo do código, vamos
primeiro siga estes passos para executar o projeto:

1. Abra o Arduino IDE.

2. A partir do Arquivo menus, abrir um novo caderno de esboços.

3. Copie o seguinte código Arduino ao esboço e guardá-lo:

int pirPin = 7; // número PIN para PIR sensor de int redLedPin = 12; // número PIN
para LED vermelho int greenLedPin = 13; // número PIN para LED verde

void setup () {
Serial.begin (9600); pinMode (pirPin, ENTRADA);
pinMode (redLedPin, OUTPUT); pinMode
(greenLedPin, OUTPUT); } Void loop () {

int pirVal = digitalRead (pirPin); if (pirVal == LOW) {// foi detectado

movimento
blinkLED (greenLedPin, "Nenhum movimento detectado."); } outro {

blinkLED (redLedPin, "movimento detectado."); }

} // Função que pisca de LED no pino número especificado vazio blinkLED (pino int, String

message) {
digitalWrite (pino, ALTA); Serial.println
(mensagem); atraso (1000);

digitalWrite (pino, LOW); atraso (2000);

}

4. Compilar e fazer o upload do esboço para a placa Arduino.

Agora, ter concluído seu projeto com o primeiro método de programação e com êxito implantado-lo ao seu
hardware. Deve estar executando o algoritmo concebido para detectar eventos de movimento e executar a ação
piscar.

Como seu projeto está funcionando corretamente, é hora de entender o código. Como qualquer outro programa Arduino, o
código tem duas funções obrigatórias: configuração() e ciclo(). Ele também tem uma função personalizada, blinkLED (), para uma ação
específica que será explicado mais tarde.

A função de configuração ()

Como você pode ver no trecho de código anterior, atribuímos variáveis ​para o pino de Arduino no início do programa. No configuração
função, que configurado essas variáveis ​para ser definido como entrada ou de saída dos pinos:

pinMode (pirPin, ENTRADA);

pinMode (redLedPin, OUTPUT); pinMode
(greenLedPin, OUTPUT);

Aqui, pirPin, redLedPin, e greenLedPin são pinos digitais 7, 12, e 13, respectivamente. Na mesma função, também
configurado na placa Arduino para fornecer série connectively na taxa de transmissão de 9.600 bps:

Serial.begin (9600);

A função loop ()
No ciclo() função, estamos monitorando constantemente a entrada do pirPin pino digital para detectar movimento. A saída
deste é pino ALTO quando o movimento é detectado e BAIXO
de outra forma. Esta lógica é implementada usando um simples if-else declaração. Quando essa condição for satisfeita, a
função chama uma função definida pelo usuário, blinkLED (), para executar a ação apropriada sobre os LEDs.

funções definidas pelo usuário são um aspecto muito importante de qualquer linguagem de programação. Vamos gastar algum

tempo aprendendo como você pode criar suas próprias funções Arduino para executar várias ações.
Trabalhando com personalizados funções Arduino
Funções são usadas quando um segmento de código é repetidamente executado para executar a mesma ação. Um usuário pode
criar uma função personalizada para organizar o código ou executar ações reoccurring. Para com sucesso utilizar uma função
personalizada, um usuário precisa chamar-los de funções Arduino obrigatórios, tais como ciclo (), de configuração (), ou qualquer outra
função que leva a estas funções obrigatórias:

-Tipo de retorno function_name (parâmetros) {

# Ação a ser executada ACTION_1;
Action_2;

expressão de retorno; }

No quadro função Arduino anterior, -Tipo de retorno pode ser qualquer tipo de dados, como Arduino int, flutuador, corda, e assim
por diante, ou vazio Se o código não estiver retornando nada. O seguinte é a função personalizada que usamos em nosso
código do projeto:

vazio blinkLED (pino int, String message) {

digitalWrite (pino, ALTA); Serial.println
(mensagem); atraso (1000);

digitalWrite (pino, LOW); atraso (2000);

}

Em nosso projeto, o blinkLED () função não é reajustar qualquer valor quando é chamado a partir do ciclo() função.
Conseqüentemente, -Tipo de retorno é vazio. Ao chamar a função, passamos o número de pinos e uma mensagem como
parâmetros:

blinkLED (greenLedPin, "Nenhum movimento detectado.");

Estes parâmetros são então utilizados na ação realizada (a escrever uma mensagem em uma porta serial e
configurar o status LED) pela blinkLED () função. Esta função também introduz um atraso para executar a ação
piscar usando a demora() função.
prova
Verificamos o sistema projetado na conexão de hardware de testes secção através de entradas manuais através do
programa de teste Firmata. Como temos agora implementou o projeto de software, é preciso verificar se o projeto é a
realização de tarefas objetivas de forma autónoma e repetidamente. Com a porta USB ligado ao computador, abra a
ferramenta de monitoramento de série do Arduino IDE navegando até ferramentas | Serial monitor ou premindo Ctrl +
Shift + M. Você deve começar a ver uma mensagem semelhante à exibida na imagem seguinte na Serial monitor janela:

Ao escrever o blinkLED () função para executar ações, incluímos uma ação para escrever uma corda através de uma porta
serial. Mova sua mão sobre o sensor PIR, de tal forma que o sensor PIR pode detectar movimento. Este evento deve
acionar o sistema a piscar o LED vermelho e exibir uma string, O movimento detectado, no monitor serial. Uma vez que você
ficar firme e evitar qualquer movimento por um tempo, você será capaz de ver o LED verde piscando até o próximo
movimento fica detectado através do sensor PIR.
Solução de problemas
Resolução de problemas é um processo importante se alguma coisa der errado. Estes são alguns exemplos de problemas e solução
de problemas etapas para eles:

saída serial é correta, mas há LEDs sem piscar:

Verifique as conexões de LED na placa de ensaio O

LED pisca, mas não há saída serial:

Verifique a porta na qual o monitor de série está configurado Verificar se a taxa de transmissão

no monitor de série está correcta (9600 bps) Não há saída em série e nenhum LED a piscar:

Verifique a conexão do sensor PIR e certifique-se que você está recebendo sinal do sensor PIR

Verifique se o seu código Arduino

Verifique as conexões de alimentação e terra

Método 2 - utilizando Python e Firmata
No capítulo anterior, discutimos os benefícios do uso de programação Python que é assistido por Firmata sobre o uso
de esboços Arduino nativas. A abordagem de programação baseada em Python fornece experiência tangível ao
realizar qualquer alteração algorítmica ou paramétricos. Nesta seção, vamos explorar estes benefícios e também
aprender importantes paradigmas de programação Python.
A configuração do projeto
Vamos ter certeza de que você tem feito o seguinte, antes de ir em frente com a programação Python:

A certeza de que os componentes de hardware são configurados, conforme descrito no projeto do sistema
Conectado a Arduino ao computador usando um cabo USB Enviado a StandardFirmata esboço de volta para
Arduino a certeza que você tem Python e os pacotes Python ( pyserial e pyFirmata)

instalado no seu computador

Obtido um editor de texto para escrever códigos Python
Trabalhando com arquivos executáveis ​em Python
Nos capítulos anteriores, nós exploramos Python programação usando o interpretador Python interativo. No entanto, quando se
trabalha com grandes projetos, é muito difícil manter usando o interpretador interativo do Python para tarefas repetitivas. Como
outras linguagens de programação, o método preferido é o de criar arquivos executáveis ​em Python e executá-los a partir do
terminal. arquivos executáveis ​Python levar a. py extensão e são formatados como texto simples. Qualquer editor de texto pode
ser usado para criar esses arquivos. Os editores populares usados ​para criar e editar arquivos Python são Notepad ++, nano, vi,
e assim por diante. Esta lista também inclui o editor padrão que é fornecido com os arquivos de instalação Python chamado
IDLE. Você pode usar o editor de sua escolha, mas certifique-se de salvar os arquivos com o. py extensão. Vamos copiar das
seguintes linhas de código em um novo arquivo e salvá-lo como test.py:

# ! / Usr / bin / python a =

"Python"
b = "Programação" imprimir
um + " "+ b

Para executar esse arquivo, execute o seguinte comando no terminal, onde o test.py arquivo é salvo:

$ Test.py python

Você deve ser capaz de ver o texto Programação Python impresso no terminal. Como você pode ver, o arquivo começa
com #! / usr / bin / pitão, que é o local de instalação Python padrão. Adicionando esta linha no seu código Python, você
pode executar diretamente um arquivo Python a partir do terminal. Em sistemas operacionais baseados em Unix,
você precisa fazer a test.py arquivo executável através do seguinte comando:

$ Chmod + x test.py

Agora, como o arquivo é executável, você pode executar diretamente o arquivo usando o seguinte comando:

$. / Test.py

Nota

Para sistemas operacionais baseados em Unix, uma forma alternativa de fornecer a localização interpretador Python é
usar a seguinte linha de código em vez de um que usamos:

# ! / Usr / bin / env python

Em sistemas operacionais Windows, Python arquivos automaticamente se tornar executável por causa da. py extensão. Você
pode apenas executar os arquivos do programa clicando duas vezes e abri-los.
O código Python
Como você já sabe como criar e executar código Python, vamos criar um novo arquivo de Python com o seguinte trecho
de código e executá-lo. Certifique-se de alterar o valor do porta variável de acordo com o seu sistema operacional,
conforme descrito no capítulo anterior:

# ! / Usr / bin / python

# Importação exigido bibliotecas importar

pyfirmata
do tempo de sono de importação

# Definir função personalizada para executar Blink ação def blinkLED (pin,
mensagem):
mensagem de impressão

board.digital [pino] .write (1) de suspensão (1)

board.digital [pino] .write (0) de suspensão (1)

# porta associado e tábua com porta pyFirmata = '/ dev / ttyACM0'

placa = pyfirmata.Arduino (porta)

# Use iteração linha para evitar buffer overflow it = pyfirmata.util.Iterator (placa)

it.start ()

# definir pinos
pirPin = board.get_pin ( 'd: 7: i') Redpin = 12 = 13
Greenpin

# Verifique para entrada de sensor PIR while

True:
# Ignorar caso quando receber Nenhum valor de valor pino = pirPin.read ()
enquanto o valor é Nenhum:

passar

se o valor for True:

# Execute Blink usando função personalizada blinkLED (Redpin,
"Movimento detectado")

outro: # Execute Blink usando função personalizada blinkLED (Greenpin,

"Nenhum movimento detectado")

# Solte o board.exit pensão ()

Você criou e executou seu primeiro projeto Arduino usando Python. Existem dois principais componentes de
programação neste código: pyFirmata métodos e o Python funcionar para realizar a acção intermitente. O
programa detecta repetidamente o movimento
eventos e executa a ação de piscar. Na seção anterior, este problema foi resolvido usando a função
Arduino padrão ciclo(). Neste método, temos implementado o
enquanto declaração para manter o programa em loop até que o código é encerrado manualmente pelo usuário. Você pode
rescindir o código usando a combinação de teclado Ctrl + C.
Trabalhando com métodos pyFirmata
Como parte do trabalho com a placa Arduino e o protocolo Firmata, você tem que começar por inicializar a placa Arduino
como uma variável. o pyFirmata método que permite que um usuário atribua a placa para uma variável Python é a seguinte:

placa = pyfirmata.Arduino (porta)

Uma vez que o valor da variável é atribuído, você pode executar várias ações, tais como a leitura de um pino ou enviando
um sinal para o pino usando essa variável. Para atribuir uma função a um pino, o get_pin () método é usado. Na seguinte linha
de código, d representa o pino digital, 7
é o número de pinos, e Eu representa que o tipo de pino é um pino de entrada:

pirPin = board.get_pin ( 'd: 7: i')

Uma vez que um pino e seu papel está atribuído a uma variável, essa variável pode ser usado para ler ou os valores de escrita no pino:

Valor = pirPin.read ()

Pode-se escrever diretamente dados em um pino específico, conforme descrito no seguinte código:

board.digital [pino] .write (1)

Aqui o write (1) método envia um ALTO sinalizar para o pino. Nós estará aprendendo adicional
pyFirmata métodos nos próximos capítulos.
Trabalhando com funções Python
Uma função Python começa com o def palavra-chave seguido pelo nome da função e os parâmetros de entrada ou
argumentos. As extremidades de definição de função com dois pontos (:) e que é recuado depois. o Retorna declaração
termina a função. Ele também passa a expressão para o lugar onde a função é chamada. Se o Retorna declaração
é mantida sem uma expressão, ele é considerado para passar o valor de retorno Nenhum: function_name def
(parâmetros):

ACTION_1
action_2
retorno [expressão]

O enquadramento anterior pode ser usado para criar funções personalizadas para executar tarefas recorrentes. Em nosso
projeto, temos a blinkLED (pino, mensagem) função para executar a ação de LED piscando. Esta função envia 1 (HIGH) e 0 (baixo) valor
para o pino digital especificado ao mesmo tempo que a impressão mensagem no terminal. Além disso, introduz atraso para
simular a ação de piscar:

def blinkLED (pino, mensagem):

mensagem de impressão

board.digital [pino] .write (1) de suspensão (1)

board.digital [pino] .write (0) de suspensão (1)

prova
Você pode começar a testar o projeto assim que você executar o código Python no terminal. Se tudo correr de
acordo com o projeto, você deve ser capaz de ver a seguinte saída no terminal:

Você deve ser capaz de ver o movimento detectado corda no terminal quando qualquer movimento é detectado pelo sensor PIR. Se
você encontrar qualquer comportamento anormal na saída, então por favor, verifique o código Python.

Uma vantagem de usar o Python é que pequenas modificações, tais como a alteração da velocidade de piscar ou
trocando papéis dos LEDs pode ser realizada por apenas mudando o código Python, sem lidar com o Arduino ou o
circuito eléctrico.
Solução de problemas
Quando você executar o projeto, você pode exigir solução de problemas para os seguintes problemas prováveis:

saída serial é correta, mas há LEDs sem piscar:

Verifique as conexões de LED na placa de ensaio O

LED pisca, mas não há saída serial:

Verifique se você instalou com sucesso o esboço Firmata padrão para o conselho

Não há saída de série e nenhum LED piscando:

Verifique se qualquer programa diferente do Python está usando a porta serial. Feche os programas que possam
estar usando essa porta de série, incluindo o Arduino IDE. Verifique todas as conexões do circuito.

Certifique-se de que o nome da porta especificado no código Python está correto.

resumo
Entre os dois métodos de programação que você aprendeu neste capítulo, o método que usa apenas um esboço
Arduino representa o paradigma tradicional de programação de um microcontrolador. Enquanto este método é
simples de implementar, falta-lhe a extensão que é conseguida pelo Python-Arduino interface. Embora vamos usar
extensa Arduino codificação em todos os projectos com início a partir de agora, exercícios e projetos terão Python-
Arduino interface como a principal forma de programação.

A partir do próximo capítulo, vamos explorar os aspectos adicionais de programação Python que podem estender a
usabilidade de um projeto de hardware baseado em Arduino, mantendo a programação níveis de dificuldade para
um mínimo. Vamos começar com Python- Arduino prototipagem e, em seguida, criar interfaces gráficas para
interação com o usuário, antes de parar para o segundo projeto que utiliza estes conceitos.
Capítulo 4. Mergulhar em Python-Arduino
Prototipagem
Após a conclusão do primeiro projeto, que começou com sucesso Python-Arduino interface. Também interface vários
componentes de hardware, ou seja, sensor de movimento e LEDs com Arduino via pinos digitais. Durante o projeto, você
aprendeu mais sobre o protocolo Firmata enquanto utilizando métodos simples em Python que ajudaram a estabelecer
uma conexão entre sua placa Arduino e o programa Python. Quando você está trabalhando em projetos complexos, você
precisa mais do que os métodos básicos para implementar os diferentes recursos que são necessários para os projetos e
seus componentes eletrônicos associados. Este capítulo é projetado para dar-lhe uma experiência completa de interface
de modo que você pode começar a trabalhar em problemas difíceis do próximo capítulo em diante. Nós descrevemos
vários protocolos interfaceamento no pitão em Arduino e níveis Arduino-a-componentes. Este capítulo também inclui
exemplos práticos para esses protocolos com diagramas de código e de circuitos apropriados. Neste capítulo, vamos
cobrir os seguintes tópicos principais:

Introdução ao Prototipagem descrição detalhada de vários pyFirmata métodos para a porta Arduino
funcionalidades em Python

exemplos de interface python-Arduino usando Firmata para componentes electrónicos básicos, tais como o
potenciómetro, o sinal sonoro, o motor de corrente contínua, e o servomotor para a Introdução circuito
inter-integrado (I2C) protocolo e exemplos de prototipagem para os componentes I2C, tais como o sensor de
temperatura (TMP102) e o sensor de luz (BH1750)
prototipagem
Apenas por um momento, passo para trás e Vamos olhar o projeto que nós construímos no capítulo anterior. O projeto tinha um
objetivo muito simples e fomos capazes de desenvolvê-lo bastante confortável. No entanto, o projeto não é certamente pronto para
ser um produto de consumo, uma vez que não tem funcionalidades significativas e, mais importante, não é um produto robusto,
que pode ser produzido repetidamente como ele é. O que você pode dizer sobre o seu projeto atual é que é um projeto de DIY
para uso pessoal ou apenas um modelo que pode ser desenvolvido para ser um grande produto.

Agora, se você estiver olhando para desenvolver um produto comercial ou apenas um projeto DIY que é realmente robusta e
escalável, você deve considerar iniciá-lo, fazendo um modelo de primeira. Nesta fase, você precisa imaginar o produto com as
características necessárias que precisam ser desenvolvidas e o número de componentes que são necessários para implantar
esses recursos. Prototipagem é basicamente uma forma rápida de criar um modelo de trabalho de sua idéia Envisioned antes
de desenvolvê-lo em um projeto totalmente funcional ou produto. A prova do protótipo conceito que é desenvolvido durante
este processo de prototipagem permite identificar a viabilidade de sua ideia e, em alguns casos, ajuda você a explorar o
potencial do seu projeto. O processo de tomada modelo funcional prototipagem ou é essencial para qualquer indústria e não
apenas para a eletrônica.

No domínio eletrônica, prototipagem pode ser usado na primeira etapa da interface componentes de um computador, em
vez de passar directamente uma quantidade significativa de recursos para o desenho esquemático, PCB fabricação e
desenvolvimento da base de código completo. Esta etapa ajuda a identificar as principais falhas em seu projeto de circuito
e verifique a compatibilidade recíproca dos componentes selecionados.

Felizmente, Arduino e o suporte de software existente em torno Arduino têm realmente simplificada prototipagem
eletrônica. Nas próximas seções, vamos passar por várias funções auxiliares e exercícios de interface para ajudá-lo
prosseguir com seus próprios projetos. Estes exemplos ou modelos são projetados de tal forma a que possam ser
usadas como um modelo para projetos maiores.

Antes de mergulhar estes exemplos de prototipagem, vamos entender duas abstrações diferentes de interface que
estamos indo para explorar neste capítulo:

Interface Arduino com Python: Temos aprendido o método mais fácil de Python- Arduino interface
usando o protocolo Firmata. Na placa Arduino, o protocolo Firmata é implementado utilizando o StandardFirmata
firmware, enquanto no final Python, foram utilizadas as bibliotecas Firmata, pyFirmata ou pyMata, para Python.
Outro método interface Python-Arduino inclui o uso de simples, mas comandos seriais fora do padrão
usando o costume Arduino esboço ea pyserial biblioteca no programa Python. Também é possível usar uma
rede de computadores para estabelecer a comunicação entre Python e Arduino, que é coberto mais tarde
no livro.

Interface componentes eletrônicos com Arduino: A abstracção segunda interface está associada
com Arduino e os componentes físicos. Como já fez, vários componentes eletrônicos podem ser
facilmente interface com a placa Arduino
utilizando pinos digitais ou analógicos. Estes componentes lidar tanto com sinais digitais ou analógicos. Alguns
pinos digitais do comunicação PWM suporte de placa Arduino para dispositivos de hardware específicos. A outra
alternativa métodos incluem a interface I2C e
série de interface periférico (SPI) comunicação. O método I2C é amplamente
explicado na seção final deste capítulo.
Trabalhando com métodos pyFirmata
o pyFirmata pacote proporciona métodos úteis para fazer a ponte entre o pitão e o protocolo de Firmata Arduino. Embora
esses métodos são descritos com exemplos específicos, você pode usá-los de várias maneiras diferentes. Esta
seção também fornece uma descrição detalhada de alguns métodos adicionais que não foram utilizados no projeto
anterior e lista os recursos que faltam.
Configurando a placa Arduino
Para configurar sua placa Arduino em um programa Python usando pyFirmata, você precisa seguir especificamente os passos
que nós cobrimos. Nós distribuímos todo o código que é necessário para o processo de configuração em pequenos trechos
de código em cada etapa. Ao escrever seu código, você terá que usar com cuidado os trechos de código que são
apropriados para a sua aplicação. Você sempre pode se referir ao exemplo arquivos Python contendo o código completo.
Antes de ir em frente, vamos primeiro ter certeza que sua placa Arduino está equipado com a mais recente versão do StandardFirmat
programa e está conectado ao seu computador:

1. Dependendo da placa Arduino que está sendo utilizado, começar por importar o apropriado pyFirmata aulas
para o código Python. Atualmente, o embutido pyFirmata
aulas só apoiar o Arduino Uno e Arduino mega placas:

de Arduino importação pyfirmata

No caso de Arduino mega, use a seguinte linha de código:

de ArduinoMega importação pyfirmata

2. Antes de iniciar a execução de quaisquer métodos que estão associados com a manipulação de pinos, você precisa
configurar adequadamente a placa Arduino. Para executar esta tarefa, temos que primeiro identificar a porta USB à
qual a placa Arduino está conectado e atribuir este local a uma variável na forma de um objeto string. Para Mac OS X,
a cadeia de porta deve aproximadamente parecido com este:

porto = '/dev/cu.usbmodemfa1331'

Para o Windows, utilize a seguinte estrutura string:

porto = 'Com3'

No caso do sistema operacional Linux, use a seguinte linha de código:

porto = '/ dev / ttyACM0'

A localização do porto pode ser diferente de acordo com a configuração do computador. Você pode identificar a
localização correta do seu porta USB Arduino usando o Arduino IDE, conforme descrito no Capítulo 2 , Trabalhando
com o Protocolo Firmata ea Biblioteca pyserial.

3. Depois de ter importado a classe Arduino e atribuiu a porta a um objeto variável, é hora de se
envolver Arduino com pyFirmata e associar esta relação para outra variável:

placa = Arduino (porta)

Da mesma forma, para Arduino mega, use o seguinte:

placa = ArduinoMega (porta)

4. A sincronização entre a placa Arduino e pyFirmata requer algum tempo.

Adicionando o tempo de sono entre a atribuição anterior e o próximo conjunto de instruções
 pode ajudar a evitar quaisquer problemas que estão relacionados com o buffer de porta serial. A maneira mais fácil de

adicionar o tempo de sono é usar o método Python embutido, sono (tempo): tempo de sono importação de suspensão (1)

o dormir() método leva segundos como o parâmetro e um número de ponto flutuante pode ser utilizado para
proporcionar o tempo de sono específico. Por exemplo, para 200 milissegundos, será sono (0,2).

Neste ponto, você sincronizou com êxito o seu Arduino Uno ou Arduino mega placa ao computador usando pyFirmata
E se você quiser usar uma variante diferente (diferente do Arduino Uno ou ArduinoMega) da placa
Arduino?

Qualquer disposição da placa em pyFirmata é definido como um objecto dicionário. O que se segue é um exemplo do
objecto dicionário para a placa Arduino:

Arduino = {
'digital': tupla (x para x no intervalo (14)), 'análogo': tupla (x para x no
intervalo (6)), 'PWM': (3, 5, 6, 9, 10, 11), 'use_ports': verdadeiro,

'Deficientes': (0, 1) # Rx, Tx, Crystal}

Para sua variante da placa Arduino, você tem que primeiro criar um objeto de dicionário personalizado. Para criar esse
objeto, você precisa saber o layout de sua placa de hardware. Por exemplo, uma placa Arduino Nano tem um layout
semelhante a uma placa Arduino regular, mas tem oito em vez de seis portas analógicas. Portanto, o objecto anterior
dicionário personalizado pode ser como se segue:

nano = {
'digital': tupla (x para x no intervalo (14)), 'análogo': tupla (x para x no
intervalo (8)), 'PWM': (3, 5, 6, 9, 10, 11), 'use_ports': verdadeiro,

'Deficientes': (0, 1) # Rx, Tx, Crystal}

Como você já sincronizadas a placa Arduino antes, modificar o layout da placa utilizando a setup_layout
(layout) método:

board.setup_layout (nano)

Este comando irá modificar o layout padrão da placa Arduino sincronizado com o layout Arduino Nano ou
qualquer outra variante para a qual você tiver personalizado o objeto de dicionário.
Configurando pinos do Arduino
Uma vez que sua placa Arduino é sincronizado, é hora de configurar os pinos digitais e analógicos que estão indo para ser
usado como parte do seu programa. Arduino placa tem pinos digitais de I / O e pinos de entrada analógicos que podem ser
utilizadas para realizar várias operações. Como já sabemos, alguns destes pinos digitais também são capazes de PWM.

O método directo
Agora, antes de começar a escrever ou ler quaisquer dados para esses pinos, temos de primeiros modos atribuir a estes
pinos. Na abordagem baseada em esboço Arduino que usamos no capítulo anterior, foi utilizado o pinMode função, isto é, pinMode
(11, ENTRADA) para esta operação. Da mesma forma, em pyFirmata, esta operação de atribuição é realizada usando o modo método
no objecto de bordo, como mostrado no seguinte fragmento de código:

de Arduino importação pyfirmata

de pyfirmata importação de entrada, saída PWM

# Configurando Arduino porta placa = bordo

'/dev/cu.usbmodemfa1331' = Arduino (porta)

# Atribuindo modos para pinos digitais board.digital [13]

.mode = SAÍDA board.analog [0] .mode = ENTRADA

o pyFirmata biblioteca inclui classes para o ENTRADA e RESULTADO modos, que são necessários para ser importados
antes de os utilizavam. O exemplo anterior mostra a delegação de pino digital 13 como uma saída e o pino
analógico 0 como uma entrada. O método é realizado em modo a variável atribuído à placa Arduino
configurada usando o
digital[] e analógico [] atribuição índice de matriz. o pyFirmata biblioteca também suporta os modos adicionais, tais

como PWM e SERVO. o PWM

modo é usado para obter resultados analógicos de pinos digitais, enquanto o SERVO modo ajuda a um pino digital para ajustar o
ângulo do veio de entre 0 a 180 graus. o PWM e SERVO modos são explicados com exemplos detalhados mais adiante neste
capítulo. Se você estiver usando qualquer um destes modos, importe suas aulas apropriadas a partir do pyFirmata biblioteca. Uma
vez que essas classes são importados do pyFirmata pacote, os modos para os pinos apropriados podem ser atribuídas usando as
seguintes linhas de código:

board.digital [3] = .mode PWM board.digital [10] =

.mode SERVO

Nota

Em electrónica, PWM é uma técnica de modulação de sinal que é muito usado para fornecer quantidade controlada de
energia para os componentes. Apesar de lidar com sinais digitais, a técnica de PWM é usado para obter resultados análogos
através da utilização de ondas quadradas e controlar a largura do sinal.

Como já sabemos, os pinos digitais da placa Arduino só pode ter dois estados, 5V
(HIGH) e 0V (LOW). Pode-se gerar impulsos quadrados de controlar o padrão de chaveamento entre alta e baixa
e, assim, gerar o pulso. Ao alterar a largura desses pulsos, você pode simular qualquer tensão entre 0V e 5V.
Como você pode ver no diagrama a seguir, temos uma onda quadrada com 25 por cento largura do ciclo de
trabalho. Isso significa que estamos simulando 0,25 * 5V = 1.25V para o período de ciclo de trabalho que:

Os suportes linguagem Arduino PWM usando o analogWrite () função, em que a faixa de tensão entre 0 V e 5 V é
linearmente dimensionado para valores entre 0 e 255. Por exemplo, 50 por cento ciclo de trabalho (simulação de
2.5V) traduz-se um valor de 127, que pode ser codificada em Arduino quanto analogWrite (13127). Aqui, o número 13 representa
o pino digital que suporta PWM na placa Arduino Uno. Do mesmo modo, um ciclo de funcionamento de 20 por
cento (1V) traduz a analogWrite (13,64).

Atribuindo modos pin

O método direto de configuração de pinos é usado principalmente para uma única linha de chamadas de execução. Em um
projeto contendo uma grande código e lógica complexa, é conveniente designar um pin com o seu papel para um objeto
variável. Com uma atribuição como este, você pode depois utilizar a variável atribuída ao longo do programa para várias
ações, em vez de chamar o método direto cada vez que você precisar usar esse pino. Dentro pyFirmata, esta tarefa pode ser
realizada utilizando o get_pin (pin_def) método:

de importação porta Arduino pyfirmata =

'/dev/cu.usbmodemfa1311' = placa Arduino (porta)

# atribuição modo pin

ledPin = board.get_pin ( 'd: 13: o')

o get_pin () método permite que você modos de pino atribuir usando o pin_def parâmetro de cadeia,
'D: 13: O'. Os três componentes de pin_def são do tipo pino, o número de pinos, e o modo de pinos separados por dois pontos (:)
operador. Os tipos de pinos (analógicos e digitais) são indicados com uma
e d respectivamente. o get_pin () método suporta três modos, Eu para entrada, o para a saída,
e p para PWM. No exemplo de código anterior, ' d: 13: o' especifica o pino digital 13 como uma saída. Em outro exemplo,
se você quiser configurar o pino analógico 1 como uma entrada, a string do parâmetro será " um: 1: i'.
Trabalhando com pinos
Agora você configurou seus pinos do Arduino, é hora de começar a realizar ações de usá-los. Dois tipos diferentes de
métodos são suportados, enquanto trabalhava com pinos: relato de métodos e métodos de operação de I / O.

Os dados de relatório

Quando os pinos se configurado em um programa, tal como pinos de entrada analógicos, que começa a enviar os valores de

entrada para a porta serial. Se o programa não utiliza esses dados de entrada, os dados começam ficando tamponada a porta

serial e rapidamente transborda. o pyFirmata biblioteca fornece os métodos de comunicação e de iterador para lidar com esse

fenômeno. o enable_reporting () método é usado para definir o pino de entrada para iniciar a geração de relatórios. Este método deve

ser utilizado antes de realizar uma operação de leitura no pino:

board.analog [3] .enable_reporting ()

Uma vez que a operação de leitura for concluída, o pino pode ser configurado para desativar o relatório:

board.analog [3] .disable_reporting ()

No exemplo anterior, assumiu-se que já tinha configurar a placa Arduino e configurado a modo do pino 3
como analógico ENTRADA.

o pyFirmata biblioteca também oferece a Repetidor () classe de lidos e os dados de identificador sobre a porta serial. Enquanto
trabalhava com pinos analógicos, recomendamos que você iniciar um fio iterador no circuito principal para atualizar o valor do
pino para o mais recente. Se o método iterator não é usado, os dados em buffer pode transbordar sua porta serial. Essa
classe é definida no
util módulo do pyFirmata pacote e precisa ser importado antes de ser utilizada no código:

de importação pyfirmata Arduino, util

# Configurando a porta de placa Arduino = 'COM3'

placa = Arduino (porta) sono (5)

# Iniciar Iterator para evitar estouro de série it = util.Iterator (bordo)

it.start ()

operações manuais

Como já configurado os pinos do Arduino para modos adequados e sua característica de relatórios, podemos
começar a monitorá-los. o pyFirmata biblioteca fornece o escrever()
e ler() métodos para os pinos configurados.

O () método de gravação

o escrever() método é usado para escrever um valor para o pino. Se o modo do pino é definido como RESULTADO,

o parâmetro de valor é um valor booleano, ou seja, 0 ou 1:

board.digital [pino] .mode = SAÍDA

board.digital [pino] .write (1)

Se você já usou um método alternativo de atribuir o modo do pino, você pode usar o
escrever() método como se segue:

ledPin = board.get_pin ( 'd: 13: o') ledPin.write (1)

No caso do sinal de PWM, o Arduino aceita um valor entre 0 e 255 que representa o comprimento do ciclo de
funcionamento entre 0 e 100 por cento. o pyFirmata biblioteca fornece um método simplificado para lidar com os
valores PWM como em vez de valores entre 0 e 255, você pode apenas fornecer um valor flutuante entre 0 e 1,0.
Por exemplo, se você quer 50 por cento um ciclo de trabalho (2.5V valor analógico), você pode especificar 0,5 com o escrever(
método. o pyFirmata biblioteca vai cuidar da tradução e envie o valor apropriado, isto é, 127, para a placa Arduino
através do protocolo Firmata:

board.digital [pino] .mode = PWM board.digital

[pino] .write (0,5)

Da mesma forma, para o método indireto de atribuição, você pode usar um código semelhante ao seguinte trecho:

pwmPin = board.get_pin ( 'd: 13: p') pwmPin.write (0,5)

Se você estiver usando o SERVO modo, você precisa fornecer o valor em graus entre 0 e
180. Infelizmente, o SERVO modo só é aplicável para atribuição direta dos pinos e estará disponível no
futuro para atribuições indiretas:

board.digital [pino] .mode = SERVO board.digital [pino]

.write (90)

O () método de leitura

o ler() método fornece um valor de saída no pino Arduino especificado. Quando o

Repetidor () classe está sendo usado, o valor recebido usando este método é o mais recente valor atualizado na porta serial.
Quando você lê um pino digital, você pode obter apenas uma das duas entradas, ALTO ou BAIXO, que se traduzirá em 1 ou 0 em
Python:

board.digital [pino] .read ()

Os pinos analógicos de Arduino linearmente traduzir as tensões de entrada entre 0 e + 5V para 0 e 1023. No
entanto, em pyFirmata, os valores entre 0 e + 5V são linearmente traduzida para os valores flutuador de 0 e 1,0. Por
exemplo, se a tensão no pino analógico é 1V, um programa Arduino vai medir um valor algo em torno de 204, mas
irá receber o valor flutuador tal como 0,2, enquanto utilizando pyFirmata de ler() método em Python.
Funções adicionais
Além do método que já foi descrito, a pyFirmata biblioteca também fornece algumas funções utilitárias para
personalização adicional, que são as seguintes:

servo_config (pino, min_pulse = 544, max_pulse = 2,400, ângulo = 0): Este método ajuda a configurar o SERVO o modo com
maior personalização, tais como o valor mínimo de pulso, o valor máximo de impulsos, e o ângulo de
partida. Pode-se definir o ângulo inicial do servomotor usando o ângulo parâmetro.

pass_time (segundos): Este método fornece uma funcionalidade semelhante ao encontrado no método padrão, o
padrão do Python dormir() que é fornecida pela Tempo módulo. No entanto, o passar o tempo função fornece um período
de tempo de não-bloqueio em segundos.
get_firmata_version (): Esta função devolve uma tupla que contém a versão do protocolo Firmata da
placa Arduino:

board.get_firmata_version () saída (): Recomendamos que você desligue a placa Arduino de pyFirmata depois de
ter concluído a execução de seu código. Isto irá liberar a porta serial, que pode ser então utilizada por
outros programas:

board.exit ()
funções futuras
o pyFirmata biblioteca está atualmente em desenvolvimento e que recebe continuamente atualizações para acrescentar e
melhorar vários métodos. Embora a maioria dos métodos Arduino nativas estão disponíveis no pyFirmata biblioteca através
do protocolo Firmata, existem algumas funções que ainda estão desaparecidas ou em desenvolvimento e eles são os
seguintes:

pulseIn / pulseOut: Estas funções Arduino nativas esperar o pino Arduino para atingir o valor especificado. O
período de espera é devolvido em microssegundos. Este método é amplamente utilizado por Ping
(distância de medição de ultra-sons) sensores. A aplicação do presente método que utiliza pyFirmata exige
grandes alterações ao protocolo Firmata padrão.

shiftin / shiftOut: Estas funções deslocar um byte de dados dentro ou para fora, um pouco de cada vez. o pyFirmata biblioteca
carece de apoios para estas funções e pode ser implementado usando os vários truques de programação Python.
Prototipagem modelos usando Firmata
O objetivo desta seção é fornecer modelos de prototipagem ao mesmo tempo, explicando vários métodos Python e
técnicas de programação. Ele tenta cobrir alguns dos sensores mais populares com exemplos de codificação que são
utilizados por projetos Arduino DIY. Esta seção é projetado para utilizar o protocolo Firmata para implementar esses
programas em Python. Ele também inclui vários paradigmas de programação Python tais como trabalhar com ciclos
indefinidos, criando funções personalizadas, trabalhar com números aleatórios, a aquisição de entradas manuais a partir da
linha, e assim por diante. Esses modelos de prototipagem são projetados de tal forma a que possam ser facilmente
incluídos em grandes projetos ou podem ser modelos para um projeto maior que pode ser desenvolvida em torno deles.
Você aprendeu sobre o pyFirmata pacote abrangente na seção anterior e só vamos utilizar esses pyFirmata funções nos próximos
exemplos. Uma biblioteca Python alternativa que suporta o protocolo Firmata é coberto mais tarde neste capítulo.
Potenciómetro - observação contínua a partir de uma entrada
analógica
Um potenciómetro é uma resistência variável que pode ser controlada utilizando um botão. Ela tem três terminais,
dos quais dois deles estão Vref e solo, enquanto que a terceira fornece uma saída variável. A saída do
potenciómetro varia entre as voltagens fornecidas, de acordo com a posição do botão. Em Arduino, você pode
conectar o potenciômetro com
+ 5V e os pinos de terra do conselho para fornecer a tensão de alimentação. Quando o terminal variável é ligada
a entrada do Arduino analógico, estes valores de tensão se traduz entre 0 e 1023, respectivamente. No caso de pyFirmata,
o valor da analógico observação se traduz entre 0 e 1.

Este modelo de codificao contendo o potenciómetro pode ser aplicada para projectos em que é necessário um controlo manual
externo para um sistema. A saída potenciómetro que se traduz à entrada analógica de Arduino pode ser utilizado para controlar um
actuador, tal como um motor ou um LED. Em alguns casos, a entrada também pode ser utilizada para controlar o fluxo do programa
através da aplicação dos seus valores de uma variável.

ligações
Ligue a saída do potenciómetro A0 pino analógico como mostrado no diagrama a seguir.
Completar o circuito, ligando Vref e os terminais de terra dos potenciómetros a + 5V e a terra da
placa Arduino respectivamente:

O código Python
Supondo que você já tem o StandardFirmata firmware carregado para a placa Arduino, você é obrigado a executar
um código Python no seu computador para completar a sua interface com o potenciômetro. modelo de código Um
Python com o nome potentiometer.py Para ajudar você a começar a trabalhar com este exemplo está localizado no
pacote de código deste livro, que pode ser baixado a partir de https://www.packtpub.com/books/content/support/1961
. Vamos abrir este arquivo para entender o programa. Como você pode ver, estamos usando o pyFirmata Biblioteca
com o outro Python módulos como Tempo e OS: de importação pyfirmata Arduino, util de tempos import os import sono

Na segunda etapa do programa, estamos a inicializar a placa Arduino e iniciar o

Repetidor () função sobre ele:

porto = 'Com3'
placa = Arduino (porta) sono (5)

it = util.Iterator (placa) it.start ()

Uma vez que a placa foi inicializado, é preciso atribuir uma função ao pino analógico, 0, como ele vai ser usado como um
pino de entrada. Estamos usando o get_pin () Método para atribuir um papel ao pino analógico, 0:

a0 = board.get_pin ( 'a: 0: i')

Agora, como parte do programa principal, precisamos monitorar continuamente a saída do potenciômetro no pino, a0,
que acabou de definir. Estamos usando o enquanto instrução para criar um loop indefinido para o script que irá ler e
imprimir a entrada analógica. O problema com este indefinido enquanto laço é que o programa não fechar
adequadamente quando é interrompida e não vai liberar a placa, executando o board.exit () método. Para evitar isso,
vamos usar outra instrução de controle do paradigma de programação Python, chamado tente / exceto: try:

while True:
p = a0.read () p
impressão
exceto KeyboardInterrupt:
board.exit () os._exit
()

Usando esta declaração, o programa irá continuar a correr o enquanto ciclo até que ocorre a interrupção de
teclado, que é Ctrl + C, eo programa irá executar o script sob o
exceto declaração. Isto inclui libertando a placa usando board.exit () e existente o programa usando o os._exit () método.
Em resumo, o programa irá continuar a imprimir a saída do potenciômetro até que alguém pressiona Ctrl + C para
interromper o programa.

Nota

o tente / excepto declaração fornece uma maneira muito eficiente de exceções captura em Python.
É aconselhável utilizar esta declaração durante todo o processo de desenvolvimento para depurar inteligentemente seus
programas. Você pode aprender sobre erros de Python e exceções dos seguintes links:

https://docs.python.org/2/reference/compound_stmts.html#try
https://docs.python.org/2/tutorial/errors.html
Campainha - gerando som padrão de alarme
sensores campainha digitais são usados ​em várias aplicações que necessitam de notificações de alarme. Estes sensores
produzem som quando eles são fornecidos com um digital ALTO valor (isto é,
+ 5V), que pode ser fornecida pelo uso de Arduino pinos digitais. Semelhante ao exemplo de LED no capítulo anterior, eles
são muito fáceis de interagir com Arduino. No entanto, em vez de executar uma saída digital simples, estamos
implementando Python truques de programação para gerar diferentes padrões de som e produzir vários efeitos sonoros. O
mesmo modelo de código também pode ser usado para produzir diferentes padrões de piscar LED.

Nota

Um sinal sonoro analógico digital pode ser encontrada em http://www.amazon.com/Arduino-Compatible-

Altifalante-Arduino-sensores / dp / B0090X0634 .

ligações
Como apresentado no diagrama do circuito seguinte, ligar o VCC e a terra da placa do sensor para 5V e o pino de terra da
placa Arduino respectivamente. Ligar o terminal de sinal do sensor para o pino digital 2 através do resistor de 220 ohm.
Você pode usar qualquer pino digital para ligar a campainha. Apenas certifique-se que você atualize o código Python para
refletir o pino que você tenha selecionado.

O código Python

No exemplo de código, dois padrões de som diferentes são gerados utilizando matrizes de atrasos de tempo. Para realizar
essas ações, vamos implementar uma função Python personalizado que vai levar o número de pinos, o tempo de
recorrência, e o número do padrão como entrada. Antes de saltar para explicar o código, vamos abrir o arquivo do
programa, buzzerPattern.py, de
pasta de código. No início do código, você pode encontrar a função Python,
buzzerPattern () que será chamado a partir do programa principal com opções apropriadas. Como esta função é o
núcleo de todo o programa, vamos tentar entendê-la. A função contém duas matrizes de padrão codificados, pattern1 e pattern2.
Cada um contém o dentro e fora de tempo para o alarme por um segundo, que é o ciclo de trabalho do padrão. Por
exemplo, em
pattern1, 0,8 representa o tempo a campainha precisa estar ligado e 0,2 representa o oposto. A função irá repetir
este padrão de alarme para retorno momentos em que é especificado pelo argumento de função. Uma vez o para loop
com o valor de retorno é iniciado, a função irá verificar o número do padrão a partir do argumento de função e
executar o padrão. Estamos usando o bandeira variável para usar alternativamente elementos do

padronizar matriz para controlar o vibrador. Uma vez que todo o ciclo de recorrência é completa, vamos desligar a campainha

completamente novo, se ele estiver ligado, e desengatar com segurança a placa utilizando a

Saída() método:

def buzzerPattern (pino, reincidência, padrão):

Pattern1 = [0,8, 0,2] pattern2 = [0,2,
0,8] bandeira = True

para i na gama (recidiva):

Se o padrão == 1:
p = Pattern1 elif padrão ==
2:
p = pattern2 mais:

imprimir "Por favor, indique padrão válido. 1 ou 2." Saída

por atraso na p:
se o sinalizador é verdadeiro:

board.digital [pino] .write (1) = bandeira sono

Falso (atraso) else:

board.digital [pino] .write (0) flag = True sono

(atraso)

board.digital [pino] .write (0) board.exit ()

Gorjeta

Se você deseja alterar os atrasos ou implementar um padrão totalmente diferente, você pode brincar com o padronizar
matrizes.

A parte restante do programa é relativamente simples, uma vez que contém código para importar bibliotecas e
inicializar a placa de Arduino. Uma vez que a placa é inicializado, vamos executar o buzzerPattern () função com o
argumento de entrada, ( 2, 10, 1). Este argumento vai pedir a função de jogar pattern1 10 vezes no número de pinos 2:

de Arduino pyfirmata importação de tempo de sono

de importação

porto = '/dev/cu.usbmodemfa1331'
placa = Arduino (porta) sono (5)

buzzerPattern (2, 10, 1)

motor DC - controlando a velocidade do motor usando PWM
DC motores são amplamente utilizados em aplicações de robótica. Estão disponíveis numa larga gama de
especificações de tensão, dependendo da aplicação. Neste exemplo, estamos utilizando um motor DC 5V porque
queremos fornecer a energia usando a placa Arduino em si. Como o pino Arduino digital só pode ter dois estados, ou
seja, HIGH (+ 5V) ou LOW ( 0V), é impossível controlar a velocidade do motor usando apenas o RESULTADO modo. Como
solução, vamos implementar a PWM Modo via pinos digitais que são capazes de suportar PWM. Enquanto estiver usando pyFirmata,
pinos configurado com o PWM Modo de tomar quaisquer valores de entrada flutuar entre 0 e 1,0, que representam 0V e 5V
respectivamente.

ligações
Dependendo da carga, motores DC às vezes pode atrair grandes quantidades de corrente e prejudicar a placa de Arduino. Para
evitar qualquer dano para a placa Arduino devido a qualquer grande consumo de corrente acidental, iremos utilizar um transistor
como um interruptor, que utiliza apenas uma pequena quantidade de corrente para controlar a grande quantidade de corrente no
motor de corrente contínua. Para completar o circuito de ligação como apresentado no diagrama a seguir, será necessário um
transistor NPN (TIP120, N2222, ou um similar), um díodo (1N4001 ou semelhante um) e uma resistência de 220 ohms, com o seu
motor de corrente contínua. Ligar a base do transístor para o pino digital 3, que também suporta o modo de PWM. Ligar os
componentes restantes tal como apresentado no diagrama:
Nota

Para saber mais sobre os terminais do transistor (coletor, emissor e base) e aos pinos transistor associar
seus respectivos terminais, você pode consultar suas fichas ou nos seguintes sites:

http://en.wikipedia.org/wiki/Transistor
http://www.onsemi.com/pub/Collateral/TIP120-D.PDF
http://www.mouser.com/ds/2/68/PN2221-2222A-11964.pdf

O código Python

A receita Python com o nome dcMotorPWM.py para um motor DC está localizado no pacote de código deste livro,
que pode ser baixado a partir de
https://www.packtpub.com/books/content/support/1961 . Abra o arquivo Python para entender melhor o uso de PWM
para controlar a velocidade do motor DC. A função personalizada,
dcMotorControl (), leva a velocidade do motor e a duração de tempo, como parâmetros de entrada, tal como descrito no seguinte fragmento de

código:

def dcMotorControl (r, deltaT):

pwmPin.write (r / 100.00) sono (deltaT)
pwmPin.write (0)

Assim como os exemplos anteriores, nós estamos usando um código semelhante para importar a biblioteca necessária e
inicializar a placa de Arduino. Após a inicialização, estamos atribuindo o modo do pino digital 3 como PWM, o que pode ser
visto a partir da utilização do get_pin ( 'd: 3: p')
método. Este código reflete o modo indireto de atribuição modo de pino que aprendemos na seção anterior:

# no modo de ajuste do pino 3 como PWM pwmPin =

board.get_pin ( 'd: 3: p')

Como parte de recolha de entradas manuais do utilizador, que está a executar uma combinação da
tente / excepto declaração (para liberar a placa na saída) ea enquanto declaração (para obter entradas contínuas do usuário). Os
introduz modelo de código do entrada() Método para obtenção de valores de mercadorias (velocidade do motor e a duração do
motor para executar o) a partir do terminal interactivo do Python. Uma vez que estes valores são obtidos a partir do usuário, o
programa chama o
dcMotorControl () função para executar a ação motora:

experimentar:

while True:
r = input ( "Enter valor para definir a velocidade do motor:") if (r> 100) ou (r <=
0):
imprimir "Enter valor apropriado." board.exit () pausa

t = entrada dcMotorControl (r, t), exceto

KeyboardInterrupt ( "Quanto tempo (em segundos)?"):

board.exit () os._exit
LED - controlar o brilho de LED usando PWM
No modelo anterior, nós controlamos a velocidade do motor DC usando PWM. Pode-se também controlar o
brilho do LED usando o mesmo método. Em vez de pedir ao usuário brilho de entrada, vamos usar o módulo
Python aleatória neste modelo. Vamos usar este módulo para gerar um número aleatório entre 1 e 100, que será
usado mais tarde para escrever esse valor no pino e, aleatoriamente, alterar o brilho do LED. este

randint () função é um recurso muito útil fornecido pela aleatória módulo e é amplamente utilizado para testar
protótipos enviando rapidamente sinais aleatórios.

Nota

o randint () função recebe o randint (startValue, endValue) sintaxe e retorna o inteiro aleatório entre o intervalo
estabelecido pela startValue e endValue.

ligações
Como usamos no projeto do capítulo anterior, vamos precisar de um resistor pull-up para conectar o LED com o pino
Arduino. Como apresentado no diagrama seguinte, basta ligar o ânodo do LED (perna mais longa) para o pino digital 11
através de uma resistência de 220 ohms e ligar o cátodo (perna mais curta) para o solo:

É importante notar que o pino digital 11 em Arduino Uno também é capaz de executar de PWM, juntamente com os
pinos digitais 3, 5, 6, 9 e 10.

O código Python

O código Python com o título ledBrightnessPWM.py para este exercício está localizado no pacote de código deste
livro, que pode ser baixado a partir de
https://www.packtpub.com/books/content/support/1961 . Abra o arquivo para explorar o código. Como você pode ver neste
modelo de código, um valor flutuante entre 0 e 1,0 é selecionado aleatoriamente antes de passá-lo para o pino PWM.
Este método gera brilho LED aleatória para um
dado período de tempo. Esta prática pode ser utilizada para gerar as amostras de entrada aleatórios para vários outros projectos
de teste.

Como você pode ver, as primeiras linhas do código importar as bibliotecas necessárias e inicializar a placa. Embora
a placa variável, / dev / cu.usbmodemfa1311, é selecionado para Mac OS
X, você pode usar o nome variável específica do seu sistema operacional no seguinte trecho de código. Você pode
obter mais informações sobre como escolher este nome variável do
Configurando a placa Arduino seção no início deste capítulo.

de importação pyfirmata Arduino, ENTRADA, PWM de tempo de

importação sono de importação aleatória

= porta placa '/dev/cu.usbmodemfa1311' = Arduino

(porta) sono (5)

Neste exemplo, estamos utilizando o método direto de cessão modo de pin. Como você pode ver no seguinte
trecho de código, o pino digital 11 está sendo atribuído ao PWM modo:

pino 11 =
board.digital [pino] .mode = PWM

Uma vez que o modo de pino é atribuído, o programa será executado um ciclo usando o para comunicado ao gerar
aleatoriamente um número inteiro entre 0 e 100, e, em seguida, envia o valor PWM apropriado para o pino de acordo
com o número gerado. Com a execução deste, você será capaz de ver o LED mudando aleatoriamente seu brilho
durante cerca de 10 segundos:

para i na gama (0, 99):

r = random.randint (1, 100)
board.digital [pino] .write (r / 100.00) sono (0,1)

Uma vez que você é feito com o loop, você precisa para desengatar com segurança a placa Arduino depois de desligar o
LED uma última vez. É uma boa prática para desligar o LED ou qualquer sensor ligado no final do programa antes de sair do
conselho, para evitar qualquer sensor de funcionar acidentalmente:

board.digital [pino] .write (0) board.exit ()

Nota

Se você quiser brilhar homogeneamente o LED em vez de mudar aleatoriamente seu brilho, substitua o
código no para loop com o seguinte fragmento de código. Aqui, estamos mudando a entrada PWM à variável
incrementando, Eu, em vez da variável aleatória, r: para i na gama (0, 99):

board.digital [pino] .write (i / 100.00) sono (0,1)

Servomotor - mover o motor para um determinado ângulo
Servomotores são amplamente utilizados componentes electrónicos em aplicações, tais como uma panela de inclinação de
controlo da câmara, os braços robóticos, movimentos do robô móvel, e assim por diante, onde é necessário um movimento
preciso do eixo do motor. Este controle preciso do veio do motor é possível por causa do decodificador de detecção de
posição, que é uma parte integrante da montagem do servomotor. Um servomotor padrão permite que o ângulo do veio a ser
ajustado entre 0 e 180 graus. o pyFirmata biblioteca fornece o SERVO modo que pode ser implementado em cada pino digital. Este
exercício prototipagem fornece um modelo e diretrizes para interface de um servomotor com Python.

ligações
Tipicamente, um servomotor tem fios que são vermelho, preto e amarelo, respectivamente, para ligar com a
energia, terra, e o sinal da placa Arduino codificados por cores. Ligue a fonte eo chão do servomotor a 5V
eo chão da placa Arduino. Como apresentado no diagrama a seguir, ligar o fio de sinal amarelo para o pino
digital 13:

Se você quiser usar qualquer outro pino digital, certifique-se de que você alterar o número de pinos no programa
Python na próxima seção. Depois de ter feito as conexões apropriadas, vamos passar para o programa Python.

O código Python

O arquivo Python constituído por este código é nomeado servoCustomAngle.py e está localizado no pacote de código
deste livro, que pode ser baixado a partir de
https://www.packtpub.com/books/content/support/19610 . Abrir este arquivo em seu Python
editor. Como outros exemplos, a seção que começa do programa contém o código para importar as bibliotecas e
configurar a placa Arduino:

de importação pyfirmata Arduino, SERVO do tempo de sono de

importação

# Configurando a porta de placa Arduino = 'COM5'

placa = Arduino (porta)

# Necessidade de dar algum tempo para pyFirmata e Arduino para dormir sincronizar (5)

Agora que você tem Python pronto para se comunicar com a placa Arduino, vamos configurar o pino digital
que vai ser usado para conectar o servomotor à placa Arduino. Vamos concluir esta tarefa, definindo o modo de
pino 13 a SERVO:

# no modo de ajuste do pino 13 como o pino SERVO = 13

board.digital [pino] .mode = SERVO

o setServoAngle (pino, ângulo) função personalizada leva os pinos em que o servomotor está conectado e o ângulo personalizado
como parâmetros de entrada. Esta função pode ser usada como parte de vários projetos grandes que envolvem servos:

# ângulo personalizada para definir Servo ângulo do motor def

setServoAngle (pino, ângulo):
board.digital [pino] .write (ângulo) sono (0,015)

Na lógica principal do presente modelo, queremos mover de forma incremental no veio do motor numa direcção até que
se atinge o ângulo máximo alcançável (180 graus) e em seguida movê-lo de volta para a posição original com a mesma
velocidade incremental. No enquanto loop, vamos pedir ao usuário para fornecer entrada para continuar essa rotina, que
será capturada usando o
raw_input () função. O usuário pode inserir o caractere y para continuar esta rotina ou introduzir qualquer outro personagem para
abortar o loop:

# Testando a função girando do motor em ambas as direções, enquanto True:

para i na gama (0, 180):

setServoAngle (pino, i) para i no intervalo
(180, 1, -1):
setServoAngle (pino, i)

# Continuar ou quebrar o processo de teste

i = raw_input ( "Enter 'y' para continuar ou Enter para sair):") se i == 'y':

passar o
resto:
board.exit () pausa

Ao trabalhar com todos estes exemplos de prototipagem, utilizou-se o método de comunicação directa através da utilização
dos pinos digitais e analógicos para ligar os sensores com Arduino. Agora, vamos familiarizar-se com outro método de
comunicação amplamente utilizado entre Arduino ea
sensores, que é chamada de comunicação I2C.
Prototipagem com o protocolo I2C
Na secção anterior, sensores ou actuadores foram comunicando directamente com Arduino via digitais, analógicas, ou
PWM pinos. Estes métodos são utilizados por um grande número de sensores básicos, de baixo nível e você será
amplamente usá-los em seu futuro Arduino projetos. Além destes métodos, há uma grande variedade de sensores
populares que são baseados em
circuito integrado (IC), que exigem diferentes formas de comunicação. Estes sensores avançados baseados-IC utilizar
I2C- ou métodos baseados em bus SPI para comunicar com o microcontrolador. Como estamos indo para usar sensores
baseados em I2C nos próximos projetos, a seção cobrirá somente o protocolo I2C e exemplo prático para entender o
protocolo de uma maneira melhor. Depois de entender os fundamentos do protocolo I2C, você pode aprender o protocolo
SPI muito rapidamente.

Nota

Você pode aprender mais sobre o protocolo SPI ea biblioteca Arduino SPI apoiou a partir dos seguintes links:

http://arduino.cc/en/Reference/SPI
http://www.instructables.com/id/Using-an-Arduino-to-Control-or-Test-an-SPI- electro /

Em 1982, a empresa Philips precisava descobrir um método simples e eficiente para estabelecer a comunicação entre um
microcontrolador e os chips periféricos em aparelhos de TV, o que levou ao desenvolvimento do protocolo de comunicação
I2C. O protocolo I2C liga o microcontrolador ou a CPU para um grande número de dispositivos periféricos de baixa velocidade
utilizando apenas dois fios. Exemplos de tais dispositivos periféricos ou sensores incluem conversores D dispositivos de I /, A
/, D / A conversores, EEPROM, e muitos outros dispositivos semelhantes. I2C usa o conceito de dispositivos de
mestre-escravo, onde o microcontrolador é o senhor e os periféricos são os dispositivos escravos. O diagrama a seguir
mostra um exemplo do barramento de comunicação I2C:
Como apresentado no diagrama anterior, o dispositivo mestre contém duas linhas bidireccionais:
Linha de dados série (SDA) e Serial linha de clock (SCL). No caso de Arduino Uno, os pinos analógicos 4 e 5
fornecem interfaces para SDA e SCL. É importante notar que estas configurações de pinos vai mudar com diferentes
variantes da placa Arduino. Os sensores periféricos que são úteis como escravos ligar a estas linhas, que são também
suportados pelas resistências de puxar. O dispositivo mestre é responsável pela geração do sinal de relógio na SCL e
inicializar a comunicação com os escravos. Os dispositivos escravos receber o relógio e responder aos comandos
enviados pelo dispositivo mestre.

A fim dos dispositivos escravos não é importante como o dispositivo principal comunica com os escravos usando
seu endereço parte. Para inicializar a comunicação, o mestre envia um dos seguintes tipos de mensagem no ônibus
com o endereço parte específica:

A única mensagem em que os dados são gravados no escravo A única

mensagem em que os dados são lidos a partir do escravo

Várias mensagens em que primeiro os dados são solicitados a partir do escravo e, em seguida, os dados recebidos são

lidos

Para suportar o protocolo I2C na programação Arduino, o Arduino IDE vem equipado com uma biblioteca padrão
chamado Fio. Esta biblioteca pode ser importado para o seu esboço Arduino, adicionando a seguinte linha de código no
início do seu programa:

# incluem <Wire.h>

Para inicializar a comunicação I2C, o Fio biblioteca usa uma combinação das seguintes funções para gravar dados
no dispositivo escravo:

Wire.beginTransmission (0x48); Wire.write (0);

Wire.endTransmission ();

Estes dispositivos escravos são diferenciadas usando endereços de peças únicas. Como você pode ver no exemplo
anterior, 0x48 é o endereço de parte de um dispositivo escravo conectada. o Fio biblioteca também oferece a Wire.read () e Wire.request
() funções para ler e solicitar dados dos dispositivos escravos. Estas funções são explicadas em detalhes na próxima
seção.

Nota

Você pode aprender mais sobre o protocolo I2C eo Fio biblioteca a partir dos seguintes links:

http://www.instructables.com/id/I2C-between-Arduinos/
http://arduino.cc/en/reference/wire
Arduino exemplos para interface I2C
De modo a praticar exercícios de protótipos para o protocolo I2C, vamos utilizar dois sensores I2C populares que
detectam a temperatura e luz ambiente no ambiente. Como o primeiro passo para mensagens I2C entendimento, vamos
trabalhar com esboços Arduino para I2C interface e, mais tarde, iremos desenvolver funcionalidades similares usando
Python.

Arduino que codifica para o sensor de temperatura TMP102

TMP102 é um dos sensores digitais amplamente utilizados para medir a temperatura ambiente. TMP102 proporciona
melhor resolução e precisão em comparação com os sensores de temperatura analógico tradicional, tais como LM35 ou
TMP36. O seguinte é uma imagem de TMP102:

Os programas de imagem anteriores um bordo de fuga com os pinos disponíveis para o sensor TMP102. Tenha em
mente que o sensor TMP102 que você obtenha pode ter um layout de pino diferente em comparação com a que é
exibida na imagem. É sempre aconselhável verificar a folha de dados de sua placa de fuga sensor antes de fazer
qualquer conexão. Como você pode ver na imagem, o sensor TMP102 suporta o protocolo I2C e está equipado com
SDA e SCL dos pinos. pins analógicos Connect 4 e 5 da sua placa Arduino Uno aos pinos SDA e SCL do sensor
TMP102. Também, conectar os + 5V e a terra, como apresentada no diagrama seguinte. Neste exemplo, estamos a
usar a placa Arduino Uno como o mestre e TMP102 como o periférico escravo, onde o endereço da parte de TMP102 é 0x48
em hexadecimal:
Nota

Você pode obter o TMP102 sensor de bordo de fuga de SparkFun Electronics em

https://www.sparkfun.com/products/11931 . A folha de

dados do produto pode ser obtido em

https://www.sparkfun.com/datasheets/Sensors/Temperature/tmp102.pdf . Agora, conecte sua placa Arduino para o
seu computador através de um cabo USB e criar um novo desenho no Arduino IDE usando o seguinte trecho de
código. Depois de ter selecionado a porta serial apropriada e tipo de placa no Arduino IDE, carregar e executar o
código. Se todas as etapas são realizadas como descrito, em execução, você será capaz de ver a leitura de
temperatura em Celsius e Fahrenheit no Serial monitor janela:

# incluem <Wire.h>
int partAddress = 0x48;

void setup () {
Serial.begin (9600); Wire.begin ();
}

void loop () {

Wire.requestFrom (partAddress, 2);

 byte MSB = Wire.read (); byte LSB =
Wire.read ();

int TemperatureData = ((MSB << 8) | LSB) >> 4;

flutuador Celsius = TemperatureData * 0,0625; Serial.print (

"Celsius:"); Serial.println (Celsius);

flutuador Fahrenheit = (1,8 * Celsius) + 32; Serial.print ( "Fahrenheit:");

Serial.println (Fahrenheit);

atraso (500); }

No fragmento de código anterior, o Wire.requestFrom (partAddress, 2) função solicita dois bytes do escravo TMP102. O
escravo envia bytes de dados para o mestre, que se capturado pelo Wire.read () função e são armazenadas como dois
bits diferentes: o bit mais significativo (MSB) e bit menos significativo (LSB). Estes bytes são convertidos em um
valor inteiro, o qual é então convertido na leitura Celsius actual multiplicando a fracção periódica do sensor TMP102
que é obtida a partir da folha de dados. TMP102 é um dos mais fácil sensores I2C para fazer a interface com
Arduino como os valores do sensor pode ser obtida através de um método simples pedido I2C.

Arduino que codifica para o sensor de luz BH1750

BH1750 é um sensor de luz digital que mede a quantidade de luz visível numa determinada área. Embora vários
projetos DIY utilizar fotocélulas simples como uma alternativa barata, o sensor BH1750 é conhecida pela maior
resolução e precisão em uma ampla gama de aplicações. A luz ambiente, também chamado fluxo luminoso ou lux, é
medido em unidades de lúmen. A comunicação suportes de sensores BH1750 I2C com endereço parte 0x23, com

0x5C como o endereço secundário, se você estiver usando vários sensores BH1750. O que se segue é uma imagem de um
bordo de fuga típica consistindo em BH1750:

Ligar os pinos SDA e SCL do bordo de fuga BH1750 aos pinos analógicos 4 e 5 da placa Arduino Uno, tal como
apresentado no diagrama de circuito seguinte. Além disso, completar o
+ conexões 5V e terra, conforme indicadas no diagrama a seguir:
No exemplo anterior, usamos funções do Fio biblioteca para completar a comunicação I2C. Apesar BH1750 é um simples e
sensor de I2C conveniente, no caso de um sensor com múltiplas capacidades de medição, não é conveniente para
código usando diretamente o Fio biblioteca. Nesta situação, você pode usar específico do sensor Arduino bibliotecas que
são desenvolvidos pelo fabricante ou a comunidade open source. Para BH1750, vamos demonstrar o uso de tal uma
biblioteca para ajudar o I2C codificação. Antes de podermos usar esta biblioteca, vamos ter que importá-lo para o
Arduino IDE. É realmente importante conhecer o processo de importação de bibliotecas para o Arduino IDE como você
vai estar a repetir esse processo para instalar outras bibliotecas no futuro. Execute as seguintes etapas para importar o BH1750
biblioteca com o Arduino IDE:

1. Faça o download e extrato Capítulo 7 , O Projeto Midterm - um portátil DIY termostato,

exemplos de código em uma pasta.

2. Abra o Arduino IDE e navegue até esboço | Importar biblioteca ... | Adicionar
Biblioteca….
3. Quando lhe for pedido para um diretório, vá para o BH1750 pasta no arquivo baixado
e clique em Selecione.
4. Para verificar se a biblioteca está instalada, para navegar esboço | Importar biblioteca ... e olhe
para BH1750 na lista drop-down.
5. Finalmente, reinicie o Arduino IDE.

Gorjeta

Se você estiver usando um Arduino IDE com a versão 1.0.4 ou uma versão mais antiga, você não pode
 ser capaz de encontrar o Importar biblioteca ... opção no menu. Neste caso, você precisa seguir o tutorial em http://a
.

o BH1750 biblioteca tem um método para obter directamente os valores de luz ambiente. Vamos testar esta biblioteca usando um

built-in exemplo de código. Depois de reiniciar o Arduino IDE, para navegar arquivo | Exemplos | BH1750 e abra a

BH1750test esboço Arduino. Isso deve abrir o seguinte trecho de código no Arduino IDE. Configurar uma porta serial
apropriada e fazer o upload do código para sua placa Arduino. Uma vez que o código é executado, você será capaz de
verificar o fluxo luminoso ( Luxo) valores usando o monitor de série do IDE Arduino. Certifique-se de que o monitor serial
está configurado para 9600:

# incluem <Wire.h>
# incluem <BH1750.h>

BH1750 lightmeter;

void setup () {
Serial.begin (9600);
lightMeter.begin ();
Serial.println ( "Running ..."); }

void loop () {
uint16_t lux = lightMeter.readLightLevel (); Serial.print ( "Light"); Serial.print
(lux); Serial.println ( "lx"); atraso (1000); }

Como você pode ver a partir do trecho de código anterior, que tenham importado a BH1750 biblioteca, incluindo BH1750.h
arquivo com Wire.h. Esta biblioteca fornece a readLightLevel ()
função, que vai buscar o valor de luz ambiente a partir do sensor e fornecê-lo como um número inteiro. Como o código
Arduino corre num circuito com um atraso de 1000 milissegundos, o Luxo
valores será obtida a partir do sensor e enviados para a porta de série a cada segundo. Você pode observar esses
valores na Serial monitor janela.
PyMata para prototipagem rápida I2C
Temos vindo a utilizar pyFirmata como a nossa biblioteca Python padrão para interface do protocolo Firmata. o pyFirmata biblioteca
é uma biblioteca Python muito útil para começar com o protocolo Firmata, pois proporciona muitos simples e
métodos eficazes para definir as portas Firmata e seus papéis. Devido a estas razões, nós extensivamente usado pyFirmata
para prototipagem rápida na seção anterior. Apesar pyFirmata suportes analógico, PWM, e modos de servo digital com
métodos fácil de usar, que fornece suporte limitado ao protocolo I2C.

Nesta seção, vamos usar uma biblioteca diferente Python Firmata chamada PyMata para se familiarizar com prototipagem
baseado em Python de sensores I2C. o PyMata biblioteca suporta métodos regulares Firmata e também fornece suporte
completo para o protocolo de mensagens I2C.

PyMata pode ser facilmente instalado usando Setuptools, que usamos nos capítulos anteriores para instalar outras
bibliotecas Python. Estamos assumindo que você já tem Setuptools e pip
no seu computador. Vamos começar a executar os seguintes passos:

1. Para instalar PyMata em um computador Windows, execute o seguinte comando no

prompt de comando:

C: \> easy_install.exe pymata

2. Se você estiver usando Linux ou Mac OS X, use o seguinte comando no terminal para instalar o PyMata biblioteca:

$ Pip sudo instalar pymata

3. Se tudo estiver configurado corretamente, este processo será concluído sem qualquer erro. Você pode confirmar PyMata
abrindo Python interativo rápida e importação PyMata:

> > > importação PyMata

4. Se a execução do comando anterior falhar, você precisa verificar o processo de instalação por qualquer
erro. Resolver o erro e repita o processo de instalação.

Interface TMP102 usando PyMata

A fim de utilizar PyMata funcionalidades, você vai precisar de sua placa Arduino ser equipados com o firmware padrão Firmata
assim como o pyFirmata biblioteca. Antes de prosseguir para explicar o PyMata funções, vamos primeiro execute o seguinte
trecho de código. Ligue o seu sensor de temperatura TMP102 como explicado na seção anterior. Usando o Arduino IDE,
para navegar arquivo | Exemplos | Firmata e fazer o upload do esboço padrão Firmata de lá para sua placa Arduino. Agora,
crie um arquivo executável Python usando o seguinte trecho de código. Alterar o valor de porta ( COM5), se necessário, para
um nome de porta apropriada conforme requerido pelo seu sistema operacional. Finalmente, execute o programa:

tempo de importação

de PyMata.pymata importação PyMata

# Inicializar Arduino utilizando o nome da porta

porto = PyMata ( "COM5")

# Configurar o pino I2C

port.i2c_config (0, port.ANALOG, 4, 5)

# Um tiro ler pedindo periférica para enviar 2 bytes port.i2c_read (0x48, 0, 2,

port.I2C_READ)
# Esperar por periférica para enviar o time.sleep dados (3)

# Leia a partir do periférico

Dados = port.i2c_get_read_data (0x48)

# Se atingir a temperatura de dados recebidos TemperatureSum = (dados de [1]

<< 8 | dados [2]) >> 4

celsius celsius = TemperatureSum * 0,0625 impressão

Fahrenheit = (1,8 * Celsius) + 32 Fahrenheit impressão

firmata.close ()

Na execução do trecho de código anterior, você será capaz de ver a leitura de temperatura em Fahrenheit e Celsius.
Como você pode ver a partir dos comentários incorporados no código, o primeiro passo para utilizar Arduino usando PyMata
é inicializar a porta usando o PyMata
construtor. PyMata suporta a configuração de I2C pinos através do i2c_config () função.
PyMata também suporta a leitura simultânea e escrita operações via i2c_read () e
i2c_write () funções.

Interface BH1750 usando PyMata

No caso de BH1750, o anterior PyMata fragmento de código pode ser utilizado com modificações menores para se obter
dados do sensor de luz ambiente. Como a primeira mudança, que pretende substituir o endereço parte de TMP102 ( 0x48) com
a uma das BH1750 ( 0x23) no seguinte trecho de código. Você também terá que converter os valores brutos recebidos do
sensor no Luxo
valor usando a fórmula dada. Após estas modificações, execute o seguinte programa a partir do terminal:

tempo de importação

de PyMata.pymata importação PyMata

porto = PyMata ( "COM5")

port.i2c_config (0, port.ANALOG, 4, 5)

# Pedido BH1750 para enviar 2 bytes port.i2c_read (0x23, 0, 2,

port.I2C_READ)
# Espere por BH1750 para enviar a time.sleep de dados
(3)

# Ler dados de BH1750

Dados = port.i2c_get_read_data (0x23)
# Obtenção de valores de lux a partir de dados recebidos LuxSum
= (dados de [1] << 8 | dados [2]) >> 4

lux = LuxSum / 1.2

imprimir str (lux) + 'lux'

firmata.close ()

Sobre a execução do trecho de código anterior, você será capaz de ver o sensor de luz ambiente leitura em Luxo no
terminal. Este processo pode ser usado em um grande número de dispositivos I2C para ler a informação registada. Em
dispositivos I2C complexos, você terá que seguir a sua folha de dados ou exemplos para organizar a ler e escrever
comandos do I2C.
comandos úteis pyserial
O protocolo padrão Firmata e bibliotecas Firmata do Python são muito úteis para o teste ou prototipagem rápida dos
sensores I2C. Embora tenham muitas vantagens, projetos baseados Firmata- enfrentar as seguintes desvantagens:

Atraso na execução em tempo real: abordagens baseadas em Firmata exigem uma série de mensagens de
comunicação serial para receber e enviar dados, o que acrescenta atraso adicional e reduz a velocidade de execução.

espaço indesejado: O protocolo Firmata contém uma grande quantidade de código adicional para apoiar várias outras
funções Arduino. Em um projeto bem definido, você realmente não precisa o conjunto completo de funções.

suporte limitado: Embora uma versão do Firmata inclui suporte I2C, é muito difícil de implementar funções I2C
complexos sem adição de atraso. Em resumo, você sempre pode usar abordagens baseadas em Firmata ao protótipo
rapidamente os seus projectos, mas quando você está trabalhando em projetos de nível de produção ou avançados, você
pode usar métodos alternativos. Nesses cenários, você pode usar código personalizado Arduino que é suportado pela
biblioteca de série do Python, pyserial, para permitir a comunicação de funcionalidades muito específicas. Nesta seção,
vamos cobrir alguns útil pyserial métodos que você pode usar se você tem que utilizar a biblioteca diretamente.

Ligar com o porta serial

Depois de ter ligado o seu Arduino a uma porta USB do seu computador, você pode abrir a porta no seu código
Python usando o Serial classe como mostrado no exemplo de código a seguir:

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

Além de nome de porta e taxa de transmissão, você também pode especificar um número de parâmetros da porta serial,
como tempo esgotado, bytesize, paridade, stopbits, e assim por diante usando Serial(). É necessário inicializar a porta serial antes de
executar qualquer outro comando do
pyserial biblioteca.

A leitura de uma linha a partir do porto

Uma vez que a porta serial é aberta, você pode começar a ler a porta usando Leia a linha(). o
Leia a linha() função requer que o tempo de espera para ser especificado ao inicializar a porta, caso contrário, o código
pode terminar com uma excepção:

A linha = port.readline ()

o Leia a linha() função vai processar cada linha a partir da porta que está encerrado com o carácter de linha final \ n.

A lavagem do porta para evitar sobrecarga da memória intermédia

Ao trabalhar com pyserial, é necessário liberar o buffer de entrada para evitar estouro de buffer e manter
operações em tempo real:
port.flushInput ()

Se a taxa de transmissão da porta é alta e o processamento dos dados de entrada é lento, buffer overflow pode ocorrer,
reduzindo a velocidade de execução e fazendo a experiência lento.

Fechar a porta
É uma boa prática de codificação para fechar a porta serial uma vez que o processo está completo. Esta prática pode
eliminar o problema de bloqueio de porta, uma vez o código Python é terminado:

port.close ()
resumo
Neste capítulo, você aprendeu métodos importantes que são necessários para fazer a interface com sucesso a placa Arduino
com Python. Também foram introduzidas para vários modelos de código de prototipagem com aplicações práticas. Esses
modelos de prototipagem nos ajudou a aprender novas Python programação paradigmas e métodos Firmata. Mais tarde, no
capítulo, mergulhou ainda mais na criação de protótipos, aprendendo mais sobre as diferentes formas de estabelecer
comunicação entre sensores e placa de Arduino. Embora nós cobrimos uma grande quantidade de conceitos de programação
com estes exemplos de prototipagem, o objetivo do capítulo era para fazer você familiarizado com os problemas de interface e
fornecer receitas rápidas para seus projetos.

Estamos assumindo que agora você está confortável testar seus sensores ou protótipos do projeto usando Python e
Arduino. É hora de começar a trabalhar para a criação de seus aplicativos que têm complexo Python recursos como
controles de usuário, gráficos e gráficos. No próximo capítulo, vamos desenvolver interfaces de usuário personalizadas
gráficas (GUIs) para seus projetos Python em Arduino.
Capítulo 5. Trabalhar com o Python GUI
Nos quatro primeiros capítulos, foi utilizado o Python monitor de alerta ou Arduino série interativo para observar os
resultados. O método de usar a saída baseada em texto na linha de comando pode ser útil para prototipagem básica e
rápida, mas quando se trata de um nível avançado de protótipos e demonstrando o seu protótipo ou produto final, você
precisa ter uma boa aparência e interface amigável. GUI ajuda os usuários a compreender os vários componentes do seu
projeto de hardware e facilmente interagir com ele. Ele também pode ajudá-lo a validar os resultados de seu projeto.

Python tem um certo número de enquadramentos da GUI amplamente utilizados, tais como Tkinter, wxPython, PyQt, PySide, e PyGTK. Cada
uma dessas estruturas possui um conjunto quase completo de recursos que são necessários para criar aplicações profissionais.
Devido à complexidade envolvida, estas estruturas têm diferentes níveis de curvas para a primeira programadores Python
aprendendo. Agora, como este livro é dedicado a programação Python para projetos baseados em Arduino, não podemos gastar
uma grande quantidade de tempo aprendendo o âmago da questão de um quadro específico. Em vez disso, vamos escolher a nossa
biblioteca de interface com base nos seguintes critérios:

Fácil de instalar e começar

Facilidade de implementar com esforços de aprendizagem insignificantes Uso

de recursos mínimos computacionais O quadro que satisfaz todos estes

requisitos é Tkinter
( https://wiki.python.org/moin/TkInter ). Tkinter é também a biblioteca GUI padrão padrão implantado com todas as
instalações do Python.

Nota

Apesar Tkinter é o pacote GUI de facto para Python, você pode aprender mais sobre outros frameworks GUI que foram
mencionados anteriormente de seus sites oficiais, que são as seguintes:

wxPython: http://www.wxpython.org/
PyGTK: http://www.pygtk.org/
PySide: http://qt-project.org/wiki/PySide
PyQt: http://sourceforge.net/projects/pyqt/
Aprendizagem Tkinter para o projeto GUI
Tkinter, abreviatura de Tk interface, é um interface de pitão de plataforma cruzada para o Tk kit de ferramentas GUI.

Tkinter fornece uma camada fina sobre o Python enquanto Tk fornece os widgets gráficas. Tkinter
é uma biblioteca multi-plataforma e é distribuído como parte de pacotes de instalação do Python para os principais sistemas
operacionais. Para Mac OS X 10.9, Tkinter é instalado com o quadro Python padrão. Para o Windows, quando você instala o
Python a partir do arquivo de instalação, Tkinter é instalado com ele.

Tkinter é projetado para levar esforços de programação mínimas para o desenvolvimento de aplicações gráficas, além de ser
poderoso o suficiente para fornecer suporte para a maioria dos recursos do aplicativo GUI. Se necessário, Tkinter também pode
ser estendido com encaixes. Tkinter através da
Tk ofertas aparência natural de um sistema operacional e sensação após o lançamento do Tk Versão 8.0. Para testar a sua

versão atual do Tk toolkit, utilize os seguintes comandos no prompt do Python:

> > > import Tkinter

> > > Tkinter._test ()

Você será solicitado com uma imagem semelhante à exibida na imagem seguinte que contém
informações sobre o seu Tk versão:

Se você enfrentar qualquer problema em conseguir esta janela, verifique a sua instalação Python e reinstalá-lo, como você
não será capaz de se mover mais à frente neste capítulo sem a Tkinter
biblioteca eo Tk conjunto de ferramentas. o Tkinter Suporta interface vários widgets para desenvolver GUIs. A tabela a

seguir descreve alguns dos elementos importantes que iremos utilizar neste capítulo:

Ferramenta Descrição

Tk () Este é o widget de raiz que é exigido por cada programa

Rótulo() Isso mostra um texto ou uma imagem

Botão() Este é um botão simples que pode ser usado para executar ações

Entrada() Este é um campo de texto para fornecer entradas para o programa

Escala() Isto fornece um valor numérico arrastando o controle deslizante

Caixa de verificação () Isto permite-lhe alternar entre dois valores, marcando a caixa

Nota

A descrição detalhada do Tkinter funções e métodos para implementar a maioria das funcionalidades fornecida pela Tk conjunto
de ferramentas pode ser obtido a partir de
https://docs.python.org/2/library/tk.html .
Seu primeiro programa Python GUI
Como discutimos em um capítulo anterior, o primeiro programa ao mesmo tempo aprender qualquer linguagem de

programação inclui impressão Olá Mundo!. Agora, como estamos começando de programação Python para a GUI, vamos

começar por imprimir a mesma seqüência em uma janela GUI em vez de um prompt. Só para começar com GUI

programação, nós estamos indo para executar um programa Python e depois saltar para explicar a estrutura e os detalhes do

código. Vamos criar um arquivo executável Python usando as seguintes linhas de código, nome dele helloGUI.py, e depois

executá-lo. O processo de execução deve completar sem erros de dependência:

import Tkinter

# Inicializar principais janelas com Tkinter.Tk () top.title ( "Olá GUI")

top.minsize título e tamanho top = (200,30)

# Widget de etiqueta
helloLabel = Tkinter.Label (em cima, text = "Olá mundo!") helloLabel.pack ()

# Iniciar e abra a janela top.mainloop ()

Você deve ser solicitado com a seguinte janela para a execução bem sucedida do trecho de código
anterior. Como você pode ver, o Olá Mundo! corda foi impresso dentro da janela e tem Olá GUI como o
título da janela:

Então, o que exatamente aconteceu? Como você pode ver a partir do trecho de código, nós instanciado várias

Tkinter Widgets um por um para obter este resultado. Estes elementos são os blocos de construção para qualquer aplicação
Python GUI que é desenvolvido usando Tkinter. Vamos começar com o primeiro e o widget mais importante, Tk ().
A raiz widget de Tk () e os métodos de alto nível
o Tk () widget de inicializa uma janela principal do vazio com uma barra de título. Este é um widget de raiz e é exigido por
cada programa apenas uma vez. A janela principal recebe sua decoração e estilos do ambiente do sistema operacional.
Portanto, quando você executar o mesmo
Tkinter código em diferentes sistemas operacionais, você vai ter o mesmo bar janela e título, mas em um estilo diferente.

Depois de criar um widget de raiz, você pode executar alguns métodos de nível superior para decorar, descrever, ou
redimensionar a janela. No código, estamos usando o título() método para definir o título da janela principal. este título() método leva
uma string como um argumento de entrada:

Top = Tkinter.Tk () top.title ( "Olá GUI")

Em seguida, chamamos minsize () método na janela principal para definir o tamanho mínimo da janela com
o argumento ( largura, altura): top.minsize (200,30)

Da mesma forma, você também pode usar o tamanho máximo() método para especificar o tamanho máximo que a janela
principal deve ter. No minsize () e tamanho máximo() métodos, os valores de largura
e altura são fornecidos no número de pixels. Uma vez que todo o programa foi instanciado, o mainloop () função é
necessária para iniciar o ciclo de eventos:

top.mainloop ()

Você não será capaz de ver quaisquer outros widgets, incluindo a janela principal, se o código não entra no ciclo de eventos
principal. O ciclo de eventos vai estar vivo até que a janela é fechada manualmente ou o método sair é chamado.

Você pode ter várias perguntas sobre a atualização da janela, programaticamente fechá-la, arranjar os widgets na grade, e
assim por diante. Há definitivamente muito mais métodos de nível superior do que as especificadas anteriormente.
A etiqueta () Widget
O outro widget usado no código ao lado Tk () é Rótulo(). o Tkinter Widgets são parte da hierarquia widget, onde Rótulo(
é o filho do widget de raiz, Tk (). Este elemento não pode ser chamado sem especificar o widget raiz ou a
janela principal em que o rótulo deve ser exibida. O principal uso desse widget é texto ou imagem na
janela principal. Na seguinte linha de código, podemos usá-lo para exibir o Olá Mundo! corda:

helloLabel = Tkinter.Label (em cima, text = "Olá mundo!")

Aqui, criado e inicializado um objeto selo chamado helloLabel, o qual tem dois parâmetros de entrada: a topo variável
que especifica o widget raiz e um texto corda. o Rótulo()
widget é altamente personalizável e aceita vários parâmetros de configuração para ajustar a largura, beira, fundo, e
justificação como opções. Exemplos envolvendo essas personalizações são cobertos nas próximas seções. Você
pode aprender mais sobre os argumentos de entrada suportados pelo http://effbot.org/tkinterbook/label.htm .
O gerente geometria pacote
O gerente geometria Pacote organiza widgets em linhas e colunas. Para usar isso, Tkinter
requer a pacote() método a ser chamado para cada widget para fazer o widget visível na janela principal:

helloLabel.pack ()

O gerente geometria Pack pode ser usado por todos Tkinter widgets, exceto raiz, para organizar o widget na janela
de raiz. No caso de vários widgets, se as posições para os widgets não são especificados, os arranjos gerente
embalá-los na mesma janela raiz. O gerente Pack é simples de implementar, mas tem uma limitação em termos
de grau de personalização. Um gerente de geometria alternativa que é útil para criar um layout complexo é
chamado Rede, o que é explicado nas próximas seções.

Nós vamos cobrir widgets adicionais e seus métodos associados nos próximos exercícios de codificação. Nestes
exercícios, vamos explicar cada widget individual com aplicações práticas para dar-lhe uma melhor compreensão
dos casos de uso.
O botão () widget - interface GUI com
Arduino e LEDs
Agora que você já teve o seu primeiro hands-on experiência na criação de uma interface gráfica Python,
vamos integrar Arduino com ele. Python facilita a interface vários pacotes heterogêneos dentro de si e que é
o que você vai fazer. No próximo exercício de codificação, usaremos Tkinter e pyFirmata para fazer o trabalho GUI
com Arduino. Neste exercício, vamos usar o Botão() Widget para controlar os LEDs em interface com a placa de
Arduino.

Antes de saltar para os exercícios, vamos construir o circuito que vamos precisar de todos os próximos programas. O que
se segue é um diagrama do circuito Fritzing onde usamos dois LEDs de cores diferentes com resistências pull up.
Conectar esses LEDs para pinos digitais 10 e 11 em sua placa Arduino Uno, como mostrado no diagrama a seguir:

Nota

Ao trabalhar com os programas previstos nesta e em futuras seções, você terá que substituir a porta Arduino que é
usada para definir a variável de placa de acordo com seu sistema operacional. Para saber qual a porta a sua placa
Arduino está conectado, siga as instruções detalhadas fornecidas Capítulo 2 , Trabalhando com o Protocolo Firmata
ea Biblioteca pyserial. Além disso, certifique-se de fornecer o número PIN correto no código se você estiver
planejando usar quaisquer outros de 10 e 11. Para alguns exercícios pinos, você terá que usar os pinos PWM, para
se certificar de que você tem pinos corretos.

No exercício anterior, pedimos que você use todo o trecho de código como um arquivo de Python e executá-lo. Isto
pode não ser possível nos próximos exercícios devido à duração do programa e da complexidade envolvida. Por isso,
reunimos esses exercícios nos arquivos de programas que podem ser acessados ​a partir da pasta de código de Capítulo
4 , em mergulho
Python-Arduino Prototipagem, que pode ser baixado a partir de
https://www.packtpub.com/books/content/support/1961 . Para o Botão() exercício widget, abra a exampleButton.py arquivo
da pasta de código de Capítulo 4 , Mergulho em Python-Arduino Prototipagem. O código contém três
componentes principais:

o pyFirmata biblioteca e Arduino configurações As Tkinter widget

de definições para um botão
A função de piscar LED que é executado quando você pressiona o botão Como você pode ver no seguinte

trecho de código, temos primeiro bibliotecas importado e inicializado a placa Arduino usando pyFirmata métodos. Para

este exercício, estamos apenas indo para o trabalho com um LED e temos inicializado somente o ledPin variável para

ele:

import Tkinter pyfirmata

importação
do tempo de sono de importação
= porta placa '/dev/cu.usbmodemfa1331' =
pyfirmata.Arduino (porta) sono (5)

ledPin = board.get_pin ( 'd: 11: o')

Nota

Como estamos usando o pyFirmata biblioteca para todos os exercícios neste capítulo, certifique-se que você enviou a
versão mais recente do desenho padrão Firmata em sua placa Arduino.

Na segunda parte do código, temos inicializado a raiz Tkinter widget como topo e forneceu uma string título.
Temos também fixa o tamanho dessa janela usando o minsize ()
método. A fim de obter mais familiarizados com o widget de raiz, você pode brincar com o tamanho
mínimo e máximo da janela:

topo Tkinter.Tk = ()
top.title ( "LED Blink utilizando o botão") top.minsize (300,30)

o Botão() Widget é um padrão Tkinter widget que é principalmente usado para se obter o manual, estímulo
externo entrada a partir do utilizador. Como o Rótulo() widget, o Botão()
widget pode ser usado para texto ou imagens. ao contrário do Rótulo() widget, ele pode ser associada a ações ou
métodos quando é pressionado. Quando o botão é pressionado,
Tkinter executa os métodos ou comandos especificados pela comando opção:

startButton = Tkinter.Button (topo,

text = "Iniciar",
comando onStartButtonPress =)
startButton.pack ()

Neste inicialização, a função associada com o botão é onStartButtonPress e a " Começar" string é exibido como o
título do botão. Da mesma forma, o topo objeto especifica o pai ou o widget raiz. Uma vez que o botão é
instanciado, você precisará usar o
pacote() método para torná-lo disponível na janela principal. Nas linhas de código anteriores, o onStartButonPress

() função inclui os scripts que

são obrigados a piscar os LEDs e alterar o estado do botão. Um estado botão pode ter o Estado como NORMAL, ATIVO,
ou DESATIVADO. Se não for especificado, o estado padrão de qualquer botão é NORMAL. o ATIVO e DESATIVADO estados
são úteis em aplicações quando repetida pressionando do botão tem de ser evitado. Depois de ligar o LED sobre o
uso do
write (1) método, vamos adicionar um atraso de 5 segundos usando o sono (5) função antes de
desligá-lo com o write (0) método:

def onStartButtonPress ():

startButton.config (estado = Tkinter.DISABLED) ledPin.write (1)

# LED é por valor fixo de tempo especificado abaixo do sono (5)

ledPin.write (0)
startButton.config (estado = Tkinter.ACTIVE)

No final do programa, que irá executar o mainloop () método para iniciar o Tkinter
ciclo. Até esta função é executada, a janela principal não aparecerá. Para executar o código, fazer mudanças
apropriadas para o Arduino borda variável e executar o programa. A imagem seguinte com uma barra de botões eo título
aparecerá como a saída do programa. Clicando no Começar botão irá ligar o LED na placa Arduino para o intervalo de
tempo especificado. Enquanto isso, quando o LED está ligado, você não será capaz de clicar no Começar botão
novamente. Agora, neste programa especial, que não forneceram código suficiente para desengatar com segurança a
placa Arduino e ele vai ser coberto nos próximos exercícios.
A entrada () widget - fornecendo entradas do usuário

manuais
No exercício anterior, você usou um botão para piscar o LED na placa Arduino para um determinado período de tempo.
Digamos que você quer mudar este intervalo de tempo fixo e especificar um valor de acordo com a exigência do seu
aplicativo. Para realizar esta operação, você vai precisar de um widget que aceita valores personalizados que podem ser
convertidos em atraso. Assim como qualquer outro quadro GUI, Tkinter fornece a interface para um widget semelhante
chamado
Entrada() e vamos utilizar isso no próximo exercício.

Manter as mesmas configurações Arduino e um LED que você usou para o exercício anterior e abrir o exampleEntry.py
Arquivo. No início do código, você vai encontrar a mesma configuração para a placa Arduino e o pino de LED
que usamos no exercício anterior. Passando para a próxima fase, você será capaz de ver o seguinte trecho de
código que define o widget raiz. Neste trecho de código, nós mudamos o título da janela principal para refletir
a premissa do exercício. O uso de cordas únicas para o título da janela irá ajudá-lo a diferenciar essas janelas
de acordo com suas propriedades, quando você está lidando com várias janelas em uma aplicação:

topo Tkinter.Tk = ()
top.title ( "Especificar tempo usando Entry")

Apesar de Entrada() widget pode ser facilmente inicializado especificando o widget pai como único parâmetro, ele também
suporta um grande número de parâmetros para personalizar o widget. Por exemplo, no nosso exercício, estamos
usando o bd parâmetro para especificar a largura da borda do widget e largura para fornecer a largura esperado do widget.
Você pode aprender mais sobre as opções disponíveis em http://effbot.org/tkinterbook/entry.htm :

timePeriodEntry = Tkinter.Entry (topo,

BD = 5, largura =
25)
timePeriodEntry.pack () timePeriodEntry.focus_set ()
startButton = Tkinter.Button (topo,

text = "Iniciar",
comando onStartButtonPress =)
startButton.pack ()

Nas linhas de código anteriores, temos inicializado dois objetos Widget em nossos janela principal:
timePeriodEntry para o Entrada() widget e botão de início que usamos no exercício anterior para o Botão() ferramenta.
O gerente geometria Pacote sempre define o ponteiro gráfica para o último elemento que foi adicionado
à janela principal. Podemos trocar manualmente o foco do ponteiro gráfica para o timePeriodEntry widget
usando o focus_set ()
método.

Ao contrário do onStartButtonPress () função no exercício anterior, esta função não usar a correção atraso
de tempo. É, em vez disso, obtém o valor do timePeriodEntry
objeto. Você pode usar o obter() método para obter o valor inserido a partir da
timePeriodEntry objeto e convertê-lo em um valor flutuante usando o flutuador() função. Como você pode ver no
seguinte trecho de código, usamos esse valor flutuante como o tempo de atraso entre a mudança o LED de
estado ligado:

def onStartButtonPress ():

# Valor de atraso é obtido a partir da entrada da entrada widget de TimePeriod =
timePeriodEntry.get () TimePeriod = flutuador (TimePeriod)

startButton.config (estado = Tkinter.DISABLED) ledPin.write (1) sono

(TimePeriod) ledPin.write (0)

startButton.config (estado = Tkinter.ACTIVE)

Uma vez que você tenha entendido o processo de inicialização do Entrada() widget e o método para obter um valor personalizado a
partir dele, vamos executar o código.

Quando você executar este exercício, você deve ser capaz de ver uma janela semelhante à exibida na imagem
seguinte. Digite um valor de atraso tempo em segundos e clique em
Começar para ver os resultados no LED. Basicamente, quando o botão é pressionado, o programa irá chamar o onStartButtonPress
() funcionar e vai utilizar esse valor para produzir o tempo de atraso.
A Escala () widget - ajustando o brilho
de um LED
Nesta seção, iremos desenvolver algum código para alterar o brilho de um LED usando o Python GUI. Anteriormente,
nós aprendemos que você pode usar um pino digital do Arduino para produzir uma saída analógica usando PWM.
Embora você possa usar o Entrada() Widget para fornecer um valor de tempo para o sinal de PWM, será útil ter um
widget que pode dinamicamente fornecer este valor. Como brilho pode ser oscilado entre 0 e 100 por cento, faz
sentido usar uma barra que varia entre 0 e 100. O Tkinter biblioteca fornece este tipo de interface deslizante usando o Escala()
ferramenta.

Como estamos trabalhando para mudar o brilho do LED e fornecer entrada analógica, estaremos usando um pino
digital com o apoio PWM. No exercício anterior, usamos pino digital
11, que já suporta PWM. Se você estiver usando uma versão personalizada do diferente do circuito ao previsto
anteriormente, recomendamos que você alterá-lo para um pino que suportes PWM. Agora é hora de abrir o arquivo do
programa, exampleScale.py, para este exercício. A primeira fase do programa, que envolve a importação das bibliotecas
necessárias e inicializar a placa Arduino usando pyFirmata é quase o mesmo que no exercício anterior. Altere a seqüência
que é usado para especificar o valor apropriado para a variável de porta de acordo com o sistema operacional e a porta
que você está usando. Também vamos instanciar a janela raiz com o título exclusivo para este exercício, como fizemos
nos exercícios anteriores. Esta parte do programa, muitas vezes, reaparecer para um grande número de exercícios e
você pode se referir ao exercício anterior, para mais informações.

Na próxima fase, vamos continuar a construir o código que desenvolvemos anteriormente para fornecer um atraso de tempo manual
para o LED. Também vamos usar a mesma Entrada() Widget para obter o intervalo de tempo como uma entrada:

timePeriodEntry = Tkinter.Entry (topo,

BD = 5, largura =
25)
timePeriodEntry.pack ()
timePeriodEntry.focus_set ()

o Escala() widget de ofertas um botão deslizante que pode ser movido através de uma escala fixa para fornecer um valor
numérico como uma saída. O arranque e os valores finais para esta escala são fornecidos utilizando o a partir de_ e para opções.
A orientação deste cursor também pode ser configurado utilizando o orientar opção, onde os valores aceitáveis ​para a
orientação são HORIZONTAL e
VERTICAL. No entanto, você terá que importar HORIZONTAL e VERTICAL As constantes da
Tkinter biblioteca antes utilizá-las aqui.

Se nenhuma opção for fornecida, o padrão Widget usa a escala de 0 a 100 e a orientação vertical. Em
nosso programa, temos utilizado a orientação horizontal como uma demonstração do orientar opção. Depois
de ter definido o objeto widget, brightnessScale, você terá que adicioná-lo ao gerente geometria pacote usando embalar
(): brightnessScale = Tkinter.Scale (topo,
 From_ = 0, a = 100, oriente =
Tkinter.HORIZONTAL)
brightnessScale.pack ()

A fim de iniciar o processo e reutilizar o código anterior, temos mantido a instanciação do botão de início widget
e o onStartButtonPress função como ele é. No entanto, a propriedade de que a função é alterada para acomodar
o Escala() ferramenta:

startButton = Tkinter.Button (topo,

text = "Iniciar",
comando onStartButtonPress =)
startButton.pack ()

Nesta versão do onStartButtonPress () função, vamos obter o ledBrightness

valor usando a obter() método no brightnessScale Widget de objeto, onde o obter()
método retornará o valor da posição atual do cursor. À medida que a entrada de PWM requer valores entre 0 e 1,
e o valor obtido deslizante é entre 0 e 100, que vai converter o valor do controle deslizante para a entrada de
PWM apropriado, dividindo-o com 100. Este novo valor, então, ser utilizado com o escrever() método e esta irá, em
última análise ligar o LED com o brilho aplicada para o período de tempo que é fornecido pela

timePeriodEntry valor:

def onStartButtonPress ():

TimePeriod = timePeriodEntry.get () TimePeriod = flutuador (TimePeriod)
ledBrightness = brightnessScale.get () ledBrightness = flutuador
(ledBrightness) startButton.config (estado = Tkinter.DISABLED)
ledPin.write (ledBrightness / 100,0) sono (TimePeriod) ledPin. write (0)

startButton.config (estado = Tkinter.ACTIVE)

Para obter informações sobre o Escala() widget, você pode se referir a

http://effbot.org/tkinterbook/scale.htm . Agora, execute o exampleScale.py Arquivo. Você será capaz de ver a imagem
seguinte com o Entrada() e Escala() Widgets. Digite o atraso de tempo, arraste o controle deslizante para o brilho que
você quer, e então clique no Começar botão:

Você será capaz de ver a luz LED se com o conjunto de brilho pelo Escala() ferramenta. Uma vez que o LED é desligado após um

determinado período de tempo, você pode redefinir o controle deslizante para outra
posição para variar dinamicamente o valor para o brilho.
O gerente geometria grade
No exercício anterior, nós adicionamos três widgets de diferentes para a janela de raiz usando o
Pacote gerenciador de geometria eo pacote() método. Nós não ativamente organizar esses widgets, mas o gerente Pacote
arranjado-los automaticamente na posição vertical. Ao projetar uma interface significativa, você precisa para organizar
esses widgets na ordem apropriada. Se você olhar para a janela de saída anterior, é realmente difícil identificar a função
de cada widget ou sua associação com os outros. A fim de projetar uma interface gráfica intuitiva, você também precisa
para descrever esses widgets usando as etiquetas apropriadas. Como uma solução,

Tkinter fornece uma forma alternativa de organizar seus widgets que é chamado Grade gerenciador de geometria.

O gerente geometria grade fornece uma bidimensional (2D) interface de tabela para organizar widgets. Cada célula
que resulta da linha e coluna da tabela de 2D pode ser usado como um lugar para os widgets. Você vai aprender as
várias opções que são fornecidos pelo rede()
classe para organizar os widgets no próximo exercício de programação. Abra o
exampleGridManager.py arquivo da pasta de código deste capítulo. Em termos de funcionalidades, este arquivo
contém o mesmo programa que nós construímos no exercício anterior. No entanto, nós adicionamos mais Rótulo() Widgets
e organizou-os usando o gerenciador de geometria grade para simplificar a GUI e torná-lo mais útil. Como você
pode observar no código, o timePeriodEntry objecto (um Entrada() widget) agora usa o rede() método em vez da pacote() método.
o rede() método é inicializado com as opções de colunas e linhas. Os valores fornecidos para estas opções de
determinar a posição da célula, onde o timePeriodEntry objecto vai ser colocado. Por outro lado, também criamos um
objeto rótulo usando o Rótulo() widget e colocou-o ao lado do Entrada() widget na mesma linha. A etiqueta contém uma
cadeia de descrição que é especificado usando o texto opção. Após a colocação do mesmo numa célula utilizando
o rede()

método, elementos são dispostos no centro em que a célula. Para alterar este alinhamento, você pode usar o pegajoso
opção com um ou mais valores de N, E, S, e W, isto é, norte, leste, sul e oeste:

timePeriodEntry = Tkinter.Entry (topo, bd = 5) timePeriodEntry.grid (coluna

= 1, linha = 1) timePeriodEntry.focus_set ()

Tkinter.Label (em cima, text = "Tempo (segundos)"). Grade (coluna = 2, linha = 1)

Temos repetiu esta prática de colocar o widget em uma célula e descrevendo-o usando um
Rótulo() Widget para os objetos do Escala() e Botão() Widgets, bem como:

brightnessScale = Tkinter.Scale (topo, From_ = 0, a = 100, oriente = Tkinter.HORIZONTAL)

brightnessScale.grid (coluna = 1, linha = 2)

Tkinter.Label (em cima, text = "Brilho (%)"). Grade (coluna = 2, linha = 2)

startButton = Tkinter.Button (em cima, text = "Iniciar", command = onStartButtonPress) startButton.grid (coluna = 1, linha = 3)

Como você pode ver no trecho de código anterior, estamos usando diferentes valores de linha para o
widgets de valores ao ter de coluna semelhantes. Como resultado, nossos widgets serão organizados na mesma
coluna e eles terão sua descrição rótulos na próxima coluna da mesma linha. Você pode pular para a janela de
saída se você quiser verificar este padrão de organização. Até agora, estávamos contando com o usuário
manualmente fechar a janela principal. No entanto, você pode criar outro Botão() widget e por isso, chamar o método
para fechar esta janela. Neste exercício de codificação, temos um botão adicional em comparação com o exercício
anterior, que é chamado exitButton. o comando parâmetro associado com este botão é Sair, que termina o laço iniciada pela Tkinte
método top.mainloop () e fecha a GUI:

exitButton = Tkinter.Button (topo,

text = "Exit", command =
top.quit)
exitButton.grid (coluna = 2, linha = 3)

Neste exemplo de código, o Sair método é inicializado como um comando opção e pode ser também ser chamado como um método:

top.quit ()

Antes de ir em frente para a próxima etapa, execute as alterações apropriadas no código e execute o
programa. Você será solicitado com uma janela semelhante à exibida na imagem seguinte:

As linhas pontilhadas do vermelho são inseridos mais tarde para ajudar a identificar a grade e eles não aparecerão na
janela que é aberta por executar o programa. Agora você pode identificar claramente o papel de cada elemento, devido à
presença do rótulo descrição ao lado deles. Na janela aberta, brincar com os valores de tempo e brilho durante a utilização
do Começar e Saída
botões para executar as ações associadas. A partir do próximo exercício, vamos começar a usar o
rede() método regularmente para organizar os widgets.
O CheckButton () widget - seleção de LEDs

Ao desenvolver projetos complexos, você vai encontrar cenários onde você tem que depender do usuário para
selecionar as opções simples ou múltiplos de um determinado conjunto de valores. Por exemplo, quando você tem
vários números de LEDs interface com a placa Arduino e você quer que o usuário selecione um LED ou LEDs que
precisam ser ativados. Este nível de personalização torna a sua interface mais interativa e útil. o Tkinter biblioteca
fornece uma interface para um widget padrão chamado CheckButton () que permite que o processo de seleção manual
das opções dadas.

Neste exercício, vamos trabalhar com ambos os LEDs, verde e vermelho, que você conectado à placa
Arduino no início. Todo o programa Python para este exercício está localizado na pasta de código com o
nome exampleCheckbutton.py. Abra o arquivo com o mesmo editor que você tem usado o tempo todo. Este
programa implementa o
CheckButton () Widget para usuários selecionar o LED vermelho e / ou verde quando o Começar botão é clicado.

Para entender toda a lógica do programa, vamos começar a partir do inicialização e importação das bibliotecas. Como
você pode ver, agora temos duas atribuições de pinos para pinos digitais 10 e 11 como Redpin e Greenpin respectivamente.
O código para a inicialização da placa Arduino é a mesma:

= porta placa '/dev/cu.usbmodemfa1331' =

pyfirmata.Arduino (porta) sono (5)

Redpin = board.get_pin ( 'd: 10: o') Greenpin = board.get_pin

( 'd: 11: o')

Em nossa utilização do CheckButton () widget, estamos usando um muito útil Tkinter

classe variável que é chamado IntVar (). o Tkinter variável pode dizer ao sistema quando o valor da variável é
alterado. Para entender melhor o Tkinter variável de classe e sua utilização específica em nosso exercício, dê
uma olhada no seguinte trecho de código do programa:

redVar = Tkinter.IntVar ()
redCheckBox = Tkinter.Checkbutton (topo,
text = "O LED vermelho",
variable = redVar)
redCheckBox.grid (coluna = 1, linha = 1)

o CheckButton () Widget permite ao usuário selecionar entre dois valores diferentes. Estes valores são normalmente 1 ( em)
ou 0 ( off), tornando o CheckButton () widget de um interruptor. Para capturar esta seleção, o variável opção é necessária
na definição widget. Uma variável pode ser inicializado usando um do Tkinter classe variável, IntVar ().

Como você pode ver, o redVar objeto variável que é instanciado usando o IntVar () classe é usada para o variável opção
durante a definição do CheckButton () ferramenta, redCheckButton.
Portanto, qualquer operação no redCheckButton objecto irá ser traduzido para o redVar
objeto variável. Como IntVar () é um Tkinter classe, ele automaticamente se encarrega de quaisquer alterações nos valores
das variáveis ​através do CheckButton () ferramenta. Portanto, é aconselhável a utilização do Tkinter classe variável para o CheckButton
() Widget em vez das variáveis ​em Python padrão. Depois de definir o CheckButton () Widget para o LED vermelho,
repetimos este processo para o LED verde, como mostrado no seguinte trecho de código:

greenVar = Tkinter.IntVar ()
greenCheckBox = Tkinter.Checkbutton (topo,
text = "LED verde", variable =
greenVar)
greenCheckBox.grid (coluna = 2, linha = 1)

Este programa também contém o Começar e Saída botões e sua respectiva associação com o onStartButtonPress
e top.quit () funções, semelhante à forma como usamos-los no exercício anterior. Quando chamado, o onStartButtonPr
função vai obter os valores da IntVar () variáveis, redVar e greenVar, usando o obter() método. Neste caso, o valor
da variável do CheckButton () Widget será 1 quando é verificado e 0

de outra forma. Isto irá permitir que o programa para enviar o valor 1 ou 0 para o pino Arduino usando o escrever() método
marcando ou desmarcando o widget e, finalmente, transformar o LED on ou off:

def onStartButtonPress ():

redPin.write (redVar.get ()) greenPin.write
(greenVar.get ())

Como você pode ver, o código também implementa um adicional Pare botão para desligar os LEDs que foram ativados
usando o Começar botão:

stopButton = Tkinter.Button (topo,

text = "Stop",
comando onStopButtonPress =)
stopButton.grid (coluna = 2, linha = 2)

o onStopButtonPrerss () função associada com este botão desliga-se ambos os LEDs usando write (0) em
ambos os pinos:

def onStopButtonPress ():

redPin.write (0) greenPin.write
(0)

Desde que você já aprendeu sobre a Tkinter variáveis ​e o CheckButton () widget, vamos executar o programa Python, exampleCheckb
Como você pode ver na imagem seguinte, o GUI tem dois CheckButton () Widgets para cada um dos LEDs vermelhos e
verdes. Como existe uma inicialização separado do CheckButton () widgets, um usuário pode verificar tanto o vermelho e
LEDs verdes. Tkinter Também fornece os widgets semelhantes, tais como Botao de radio() e

Caixa de listagem () para os casos em que você deseja selecionar apenas um único valor a partir das opções dadas.
Nota

Você pode aprender mais sobre a Botao de radio() e Caixa de listagem () Widgets partir das seguintes páginas web:

http://effbot.org/tkinterbook/radiobutton.htm
http://effbot.org/tkinterbook/listbox.htm
A etiqueta () widget - monitoramento I O pins /
Arduino projectos muitas vezes lidar com sistemas de tempo real e são obrigados a monitorar continuamente os valores de
entrada dos pinos digitais e analógicos. Portanto, se esses valores estão sendo exibidos em uma interface gráfica, eles precisam
ser atualizados periodicamente ou quando o estado de um pino muda.

Se você observar os exercícios GUI anteriores, você vai notar que inicializado janela de raiz usando mainloop () no
final do código, que iniciou o Tkinter loop e inicializado todos os widgets com os valores atualizados. Uma vez o mainloop
() foi inicializado, nós não utilizar qualquer outra Tkinter classe ou método para atualizar periodicamente os widgets
com os valores mais recentes.

Neste exercício, iremos utilizar um potenciómetro variável para proporcionar entrada para o pino analógico 0, que irá ser
reflectida por Tkinter de Rótulo() ferramenta. Para atualizar o rótulo e exibir os valores da entrada analógica, vamos
implementar alguns Python e Tkinter truques. Como estamos usando um potenciômetro para fornecer entrada, você vai
precisar para mudar o circuito como mostrado no diagrama a seguir, antes de saltar para o programa Python:

O arquivo Python para este exercício está localizado na pasta de código como o

workingWithLabels.py Arquivo. Para este exercício, vamos executar o código primeiro a entender a premissa do
exercício. Certifique-se de que você tem o valor apropriado para a placa Arduino quando você definir o porta variável.
Na execução bem-sucedida, o programa exibirá a tela a seguir e você pode clicar no Começar botão para
iniciar a
atualização contínua do potenciômetro é valor de entrada:

Então, como vamos fazer isso? Este código contém lógica complexa e um fluxo de programa diferente em comparação com o que

temos feito até agora. Como você pode ver a partir do código, estamos usando uma variável chamada bandeira para controlar o estado

do Saída botão durante a execução continuamente a

enquanto loop que monitores e actualizações do valor. Para entender o programa corretamente, vamos primeiro se
familiarizar com a seguinte nova Tkinter classes e métodos:

BooleanVar (): Assim como o IntVar () classe variável que foi utilizado para rastrear os valores inteiros, BooleanVar () é um Tkinter
classe variável que controla as alterações em booleana:

bandeira = Tkinter.BooleanVar (topo) flag.set

(Verdadeiro)

No trecho de código anterior, criamos um objeto variável, bandeira, usando o

BooleanVar () classe e definir o valor do objeto como Verdade. Sendo um objeto Boolean,
bandeira só pode ter dois valores, Verdade ou Falso. Tkinter também fornece classes para cordas e tipo double com o StringVar
() e DoubleVar () as classes respectivamente. Devido a isso, quando o Começar botão é clicado, o sistema inicia
a atualização do analógico valor lido. o Saída Button Sets os bandeira a variável falso, quebra o enquanto laço, e
interrompe o processo de monitorização.

update_idletasks: Durante o uso da Tkinter biblioteca em Python, você pode ligar um código Python a quaisquer mudanças que
acontecem em um Tk () ferramenta. Este código Python ligada é chamado de ligue de volta. o update_idletasks método chama todas
as tarefas ociosas sem processar quaisquer chamadas de retorno. Este método também redesenha os widgets geometria, se
necessário:

AnalogReadLabel.update_idletasks ()

Em nosso exercício, este método pode ser usado para atualizar continuamente a etiqueta com o valor mais recente

potenciômetro.

atualizar: Este método de nível superior processa todos os eventos pendentes e retornos de chamada e também redesenha

qualquer widget, se for necessário:

top.update ()

Nós estamos usando este método com janela de raiz para que ele possa realizar o retorno de chamada para o Começar botão.

Agora vamos voltar para o programa Python aberto. Como você pode ver, além de atribuir um pino analógico
através do get_pin () método e inicializar o Repetidor () classe sobre a placa Arduino, o código contém padrões de
programação semelhantes que usamos nos exercícios para o outro Tkinter Widgets. Neste código, estamos realizando
a operação de leitura
para o pino no interior do análogo onStartButtonPress () Esta função verifica o status do bandeira variável ao
executar o ler() operação no pino e, posteriormente, atualiza o valor do analogReadLabel () Widget se o valor
do bandeira
variável é Verdade. Se o valor do bandeira variável é encontrado para ser Falso, a função irá sair depois de
desengatar a placa Arduino e fechar a janela de raiz. Devido ao uso da enquanto declaração, este processo
irá verificar continuamente a bandeira valor até que seja quebrada pela onExitButtonPress () função alterando o bandeira
valor a Falso: def onStartButtonPress ():

while True:
se flag.get ():
analogReadLabel.config (text = str (a0.read ()))
analogReadLabel.update_idletasks () top.update () else:

board.exit
ruptura () top.destroy ()

o onExitButtonPress () função é chamada a partir do Saída botão e ele simplesmente redefine o

bandeira a variável Falso usando o conjunto() método:

def onExitButtonPress ():

flag.set (False)
Refazendo seu primeiro projeto Python no Arduino
com uma GUI
Só para refrescar sua memória, eu gostaria de lembrá-lo que nós criamos um sistema de detecção de movimento que os
alertas gerados por piscar o LED vermelho quando um movimento foi detectado. Enquanto trabalha com o projeto, que
estava imprimindo o estado do sensor de proximidade para o prompt de Python. Neste exercício, vamos utilizar os
conceitos que você aprendeu nos exercícios anteriores e vamos criar uma interface para o nosso projeto. Como parte
deste exercício, você tem que ligar o mesmo circuito que usamos no Capítulo 3 ,

O primeiro projeto - LEDs Motion-disparado. Certifique-se de que você tem exatamente o mesmo circuito com o sensor PIR e
os LEDs antes de seguir em frente. Quando estiver pronto com o seu hardware, abrir o firstProjectWithGUI.py arquivo da pasta de
código deste capítulo. No código, alterar os valores de portas apropriadas e executar o GUI para o projeto. Como você pode
ver nas atribuições de pinos, agora temos três pinos e dois digitais deles como saídas e um como uma entrada. Os pinos de
saída são atribuídos para os LEDs vermelhos e verdes, enquanto o pino de entrada é atribuído ao sensor de movimento de
PIR. Se o sensor PIR está em modo de espera, vamos realizar uma única vez ler() operação para acordar o sensor:

pirPin = board.get_pin ( 'd: 8: i') = Redpin board.get_pin ( 'd:

10: o') Greenpin = board.get_pin ( 'd: 11: o') pirPin.read ()

Uma das funções importantes que é implementado pelo código é blinkLED (). Esta função atualiza o Rótulo() widget que é
atribuído para descrever o estado do sensor de movimento. Ele também pisca os LEDs físicos usando o escrever() método
e o tempo de atraso inserido. Como parâmetros de entrada, o blinkLED () função aceita o objeto pino e uma cadeia de
mensagem da chamada de função, onde o pino de objetos, ou seja, Redpin ou Greenpin, deve ser um dos a atribuição de
pinos para os LEDs:

def blinkLED (pino, mensagem):

MotionLabel.config (text = mensagem)
MotionLabel.update_idletasks () top.update () pin.write
(1) do sono (1)

pin.write (0) de
suspensão (1)

Os outros dois Tkinter funções relacionadas, onStartButtonPress () e

onExitButtonPress (), são, basicamente, decorrentes do exercício anterior. Nesta versão do
onStartButtonPress (), que chamamos de blinkLED () função se o bandeira variável é Verdade e o movimento é
detectado usando pinPir.read (): def onStartButtonPress ():

while True:
se flag.get ():
 se pirPin.read () é True:
blinkLED (Redpin, "Movimento detectado") else:

blinkLED (Greenpin, "Nenhum movimento detectado") else:

board.exit
ruptura () top.destroy ()

O programa também instancia dois botões, Começar e Saída, e uma etiqueta usando os métodos semelhantes
aos que usamos nos exercícios anteriores.

Como você pode observar a partir do código, a lógica por trás do sistema de detecção de movimento ainda é o mesmo. Estamos apenas

a adição de uma camada de interface gráfica para indicar o estado do movimento detectado continuamente usando um Rótulo() ferramenta.

Nós também adicionamos a Começar e Saída

botões para controlar o ciclo de execução do projeto. Uma vez que você executar o código, você será capaz de ver
uma janela semelhante à exibida na imagem seguinte. Clique no Começar
botão e onda na frente do sensor de movimento. Se o sensor detecta o movimento, o rótulo mudará de Nenhum movimento
detectado para O movimento detectado.
resumo
Agora você tem hands-on experiência de construir uma GUI básica para lidar com projetos Arduino. Com pequenas modificações
para os exercícios incluídos, você pode usá-los para criar uma GUI para uma grande variedade de projetos de prototipagem
Arduino. Nos dois exercícios anteriores, apresentadas as saídas do sensor de cordas em widgets de etiqueta. Ele será mais
significativo se esses valores numéricos são plotados como um gráfico e armazenados para posterior análise. Isto é o que você
está indo para executar no próximo capítulo.
Capítulo 6. Armazenar e plotagem Arduino Dados

Sensores que estão ligados ao Arduino lotes do produto de dados analógicos e digitais. sensores analógicos produzir pontos de

dados como informação numérica, enquanto sensores digitais produzem valores booleanos, isto é, um (a) ou 0 (desligado). Até

agora, nós impressa esses dados como uma string no prompt de comando ou exibido-lo em uma GUI. Os dados estavam sendo

impressos em tempo real e não estava sendo guardado para uma análise mais aprofundada. Em vez de usar o formato de cadeia,

se os dados são impressos como uma trama ou gráfico, que irá fornecer informações úteis para nós compreendê-lo e conclusões da

deriva rapidamente. Parcelas são ainda mais útil para aplicações em tempo real como eles podem fornecer informações sobre o

comportamento do sistema para uma melhor compreensão dos dados. Este capítulo está organizado em torno de dois grandes

seções: armazenar os dados do sensor de Arduino e plotagem esses dados. Vamos começar por criar e manipular arquivos usando

Python. Depois disso, vamos trabalhar com métodos para armazenar Arduino dados no formato de arquivo CSV. Na segunda seção,

você será introduzido para a biblioteca de plotagem Python, matplotlib. Então, vamos trabalhar com exemplos que lidam com plotagem

dados de um arquivo salvo e também a partir de leituras de sensores em tempo real. No final, vamos tentar integrar o matplotlib parcelas

com o Tkinter

janela que nós criamos no capítulo anterior.

Em termos de componentes de hardware, nós estaremos trabalhando com sensores conhecidos, como um potenciômetro eo
sensor de movimentos PIR, que usamos nos capítulos anteriores, assim, você não terá que aprender ou compra de sensores
adicionais para este capítulo.
Trabalhando com arquivos em Python
Python fornece built-in métodos para criar e modificar arquivos. operações Python-relacionado arquivos são úteis
para um grande número de exercícios de programação. Estes métodos são fornecidos por módulos padrão Python
e não requer instalação de pacotes adicionais.
A) Método (aberta
o aberto() método é um método padrão que está disponível em Python e é uma das funções mais utilizadas para
manipular arquivos. Agora, o primeiro passo de lidar com um arquivo é para abri-lo:

> > > F = aberto ( 'text.txt', 'w')

Este comando irá criar um test.txt arquivo na mesma pasta em que você começou o interpretador Python ou o
local de onde o código está sendo executado. O comando das utilizações anteriores, W modo que abre um
arquivo para escrever ou cria um novo se ele não existir. Os outros modos que podem ser usados ​com o aberto() função
são exibidos na tabela a seguir:

modo Descrição

W Isso abre ou cria um arquivo somente para escrita. Ele substitui um arquivo existente.

w+ Isso abre ou cria um arquivo para escrita e leitura. Ele substitui um arquivo existente.

r Isso abre um arquivo somente para leitura.

r+ Isso abre um arquivo para leitura e escrita.

uma Isso abre um arquivo para acrescentar. Ele começa a anexar a partir do final do documento.

a+ Isso abre um arquivo para acrescentar e leitura. Ele começa a anexar a partir do final do documento.

Nota

Certifique-se que você tem as permissões de leitura e gravação apropriadas para os arquivos se você estiver utilizando estes
modos em um ambiente Unix ou Linux.
O () método de gravação
Quando o arquivo é aberto em um dos a escrita ou anexar modos, você pode começar a escrever para o objeto de arquivo usando este

método. o escrever() método leva apenas uma string como um argumento de entrada. Qualquer outro formato de dados precisa ser

convertido em uma string antes de ser escrito:

> > > f.write ( "Olá mundo! \ n")

Neste exemplo, estamos escrevendo a Olá Mundo! string que termina com um caractere de nova linha, \ n. Este caractere
de nova linha foi explicado no capítulo anterior e você pode obter mais informações sobre ele em http://en.wikipedia.org/wiki/Ne
. Você também pode usar o writelines () método se você quer escrever uma sequência de strings para o arquivo:

> > > quadrados = [ "programação Python para Arduino \ n", "Bye \ n"]
> > > f.writelines (sq)
O () Método perto
o fechar() método fecha os recursos de arquivo e de sistema livre que são ocupados pelo arquivo. Uma vez que eles estão fechados, você
não pode usar o objeto de arquivo, uma vez que já foi liberado. É uma boa prática para fechar o arquivo Assim que estiver pronto a
trabalhar com um arquivo:

> > > f.close ()

O () método de leitura
este ler() método lê o conteúdo de um arquivo aberto desde o início até o fim. Para utilizar este método, você
precisa abrir o arquivo com um dos modos compatíveis leitura como w +, r, r +, ou a +:

> > > F = aberto ( 'text.txt', 'r')

> > > f.read ()
'Olá Mundo! \ Programação nPython para Arduino \ nBye \ n'
> > > f.close ()

Enquanto o ler() método agarra todo o conteúdo do arquivo na memória, você pode usá-lo com o parâmetro de tamanho opcional

para evitar qualquer congestionamento de memória enquanto estiver trabalhando com arquivos grandes. Como um método

alternativo, você pode usar o readlines () método para ler o conteúdo de um arquivo linha aberta por linha:

> > > F = aberto ( 'text.txt', 'r')

> > > l = f.readlines ()
> > > print l
[ 'Olá Mundo! \ N', 'de programação Python para Arduino \ n', 'Bye \ n']
> > > f.close ()

Como você pode ver no exemplo anterior, cada corda é impresso como um elemento de uma lista que você pode acessar
individualmente. Você pode brincar com estes métodos para se familiarizar com a criação e modificação de arquivos. Estes
exercícios vão ser útil para os próximos exercícios de codificação.
O com a afirmação - gerente de contexto Python
Apesar de com declaração pode ser usado para cobrir a execução de um bloco de código que é definido por um
gerente de contexto, é amplamente utilizado em Python para lidar com arquivos. Execute o seguinte comando no
prompt do Python interativo, assumindo que você já executou os comandos anteriores e têm o test.txt arquivo com
alguns dados:

> > > com aberto ( 'text.txt', 'r') como f: = linhas

(f.readlines) para l em linhas:

print l

Em execução, você será capaz de ver cada linha do arquivo impresso em prompt de comando. o com declaração
enquanto utilizado com o aberto() método cria um gerente de contexto, que executa o código envolveu enquanto
automaticamente cuidar de fechar o arquivo. Este é o método recomendado para trabalhar com arquivos em Python e
estaremos utilizando-o em todos os nossos exercícios. Você pode aprender mais sobre o gerente contexto Python nos
seguintes sites:

https://docs.python.org/2/reference/compound_stmts.html#with
http://preshing.com/20110920/the-python-with-statement-by-example/
Uso de arquivos CSV para armazenar dados
Agora você sabe métodos para abrir, manipular e fechar arquivos usando Python. Nos exemplos anteriores, foram utilizados os dados

de intérprete e string Python para se familiarizar com esses métodos. Mas quando se trata de salvar um grande número de valores

numéricos a partir de dados do sensor, o Os valores separados por vírgulas (CSV) formato de arquivo é uma das outras do que o texto

formatos de arquivo mais utilizados. Como o nome indica, os valores são separados e armazenados utilizando vírgulas ou outros

delimitadores, tais como um espaço ou guia. Python tem um built-in módulo para lidar com arquivos CSV.

Para começar, use o seguinte trecho de código para criar um arquivo de Python e executar o seu primeiro programa de CSV:

csv importação
Dados = [[1, 2, 3], [ 'a', 'b', 'c'], [ 'Python', 'Arduino', 'programação']]

com open ( 'example.csv', 'w') como f:

w = csv.writer (f) para a linha
de dados:
w.writerow (linha)

Você também pode abrir o csvWriter.py arquivo da pasta de código deste capítulo, que contém o mesmo código. Depois de
executar o código, você será capaz de encontrar um arquivo chamado
example.csv no mesmo local que este ficheiro, o qual conterá os dados separados por vírgulas.

Como você pode ver no código, o módulo CSV oferece a escritor() função no arquivo aberto que inicializa um escritor objeto. o escritor
objecto leva uma sequência ou matriz de dados (inteiro, ponto flutuante, corda, e assim por diante) como entrada e
junta-se os valores desta matriz usando o carácter delimitador:

w = csv.writer (f)

No exemplo anterior, uma vez que não estiver usando uma opção de delimitador, o programa vai levar a vírgula caracteres
padrão como delimitador. Se você quiser usar o espaço como o caractere delimitador, você pode usar o seguinte escritor() opção:

w = csv.writer (f, delimitador =' ')

Para escrever cada elemento de uma lista para uma nova linha de esta escritor objeto, usamos o writerow ()
método.

Da mesma forma, o módulo de Python CSV também fornece o leitor() função para ler um arquivo CSV. Confira o
exemplo a seguir para saber mais sobre esta função, ou você pode abrir o
csvReader.py arquivo da pasta de código do próximo capítulo:

csv importação
com open ( 'example.csv', 'r') como arquivo:
r = csv.reader (arquivo) para linha
na r:
linha de impressão
o leitor() cria uma função leitor objeto para interagir sobre linhas no arquivo CSV aberto. O objecto leitor recupera cada
elemento de uma linha de divisão que utilizando o delimitador. Você pode acessar cada linha do arquivo por iteração
sobre o objeto usando o para laço como apresentado no fragmento de código anterior, ou utilizar o Próximo() método cada vez
que você quiser acessar a próxima linha. Na execução do código anterior, você será capaz de ver três listas de matriz
separadas que são impressos com três elementos individuais.

Gorjeta

Para abrir os arquivos CSV externamente, você pode usar um programa de planilha como o Microsoft Excel, OpenOffice
Calc, ou Números da Apple.
O armazenamento de dados do Arduino em um arquivo CSV
Nas duas seções anteriores, você aprendeu métodos para armazenar valores em um arquivo CSV. Embora os dados necessários
para o arquivo já foi inicializado no código, o mesmo código pode ser modificado para armazenar Arduino dados introduzidos.

Para começar com o armazenamento Arduino dados, vamos criar um circuito que produz esses valores para nós. Foi
utilizado um sensor de movimento no projeto de Capítulo 3 , O primeiro projeto - LEDs Motion-acionados, e um potenciômetro
no exercício de Capítulo 4 , Mergulho em Python-Arduino Prototipagem. Iremos utilizar estes dois sensores nos fornecer valores
de entrada digital e analógico, respectivamente. Para desenvolver o circuito necessário para este exercício, ligar o
potenciómetro para o pino analógico 0 e o sensor de PIR movimento ao pino digital 11, como apresentado no diagrama a
seguir:
Conectar outros pinos Arduino, tais como 5V e a terra, como mostrado no diagrama Fritzing anterior. Como estamos
indo para uso pyFirmata a interface Python com a placa Arduino, você terá que fazer o upload do StandardFirmata esboçar
para a placa Arduino utilizando o método descrito em Capítulo 3 , O primeiro projeto - LEDs Motion-disparado.

Nota

Quando você está trabalhando com protótipos, você realmente não precisa de grandes bases de dados, poderosas e de
computação intensa para lidar com a informação. A maneira mais fácil e rápida de trabalhar com dados do sensor nesta fase é
usando arquivos CSV.

Depois de ter sua placa Arduino pronto com as conexões apropriadas, use o seguinte trecho de código para criar
um arquivo de Python e executá-lo. Você também pode abrir o
csvArduinoStore.py arquivo da pasta de código deste capítulo:

csv importação
pyfirmata importação
do tempo de sono de importação

= porta placa '/dev/cu.usbmodemfa1331' =

pyfirmata.Arduino (porta)

it = pyfirmata.util.Iterator (placa) it.start ()

pirPin = board.get_pin ( 'd: 11: i') = a0 board.get_pin ( 'a:

0: i')

com open ( 'SensorDataStore.csv', 'w') como f:

w = csv.writer (f)
w.writerow ([ "N", "Potenciómetro", "Sensor de Movimento"]) i = 0

pirData = pirPin.read () potData =

a0.read () enquanto i <25:

sono (1)
se pirData não é None:
i+1=
fileira = [i, potData, pirData]
w.writerow (linha)
imprimir "Feito. arquivo CSV está pronto!"

board.exit ()

Enquanto o código está sendo executado, gire o botão do potenciômetro e acenar com a mão na frente dos sensores
de movimento. Esta ação irá ajudá-lo a gerar e medir valores distintos a partir desses sensores. Enquanto isso, o
programa irá registrar esses dados no
SensorDataStore.csv Arquivo. Quando concluída, abra o SensorDataStore.csv arquivo usando qualquer programa visualizador de
texto ou planilha e você será capaz de ver esses valores do sensor armazenados no arquivo. Agora, vamos tentar
entender o programa.

Como você pode observar a partir do código, não estão utilizando um novo módulo de interface os valores de tabuleiro ou de
sensores loja Arduino para o arquivo. Em vez disso, nós utilizamos os mesmos métodos que usamos nos exercícios anteriores.
O código tem duas componentes distintas: Python-Arduino interface e armazenamento de dados para um ficheiro CSV. Ao pular
a explicação
pyFirmata métodos para fazer a interface da placa Arduino, vamos foco no código que está associado com o
armazenamento dos dados do sensor. A primeira linha que vai escrever para o arquivo CSV usando writerow () é a linha de
cabeçalho que explica o conteúdo das colunas:

w.writerow ([ "N", "Potenciómetro", "Sensor de Movimento"])

Mais tarde, vamos obter as leituras dos sensores e gravá-los para o arquivo CSV, como mostrado no seguinte trecho
de código. Vamos repetir esse processo 25 vezes, tal como definido pela variável, Eu. Você pode alterar o valor de Eu de
acordo com suas necessidades.

enquanto i <25:
 sono (1)
se pirData não é None:
i+1=
fileira = [i, potData, pirData]
w.writerow (linha)

A próxima questão é como você pode utilizar este exercício de codificação em seus projetos personalizados? O programa tem três
seções principais que podem ser personalizados para cumprir seus requisitos de projeto, que são as seguintes:

pinos do Arduino: Você pode alterar os números de pinos do Arduino e o número de pinos a serem utilizados. Você pode fazer

isso adicionando valores dos sensores adicionais para o objeto de linha.

O arquivo CSV: O nome do arquivo e sua localização pode ser alterada de

SensorDataStore.csv ao que é específico para a sua aplicação.
O número de pontos de dados: Reunimos 25 pares diferentes de pontos de dados durante a execução do enquanto ciclo
durante 25 iterações. Você pode alterar esse valor. Você também pode alterar o intervalo de tempo entre cada ponto
sucessivo de um segundo, como usado no programa, para o valor que você precisa.
Começando com matplotlib
o matplotlib biblioteca é uma das bibliotecas mais populares e amplamente apoiadas plotagem Python. Apesar matplotlib é
inspirado em MATLAB, é independente do MATLAB. Semelhante a outras bibliotecas Python que temos vindo a
utilizar, é uma biblioteca Python de código aberto. o matplotlib auxilia biblioteca na criação 2D lotes de linhas simples de
código a partir de fácil de usar built-in funções e métodos. o matplotlib biblioteca é usada extensivamente em aplicações
baseadas no pitão para visualização de dados e análise. ele utiliza NumPy ( a forma abreviada do Python numérica) e SciPy
( forma abreviada de Python científica) pacotes para cálculos matemáticos para a análise. Estes pacotes são as
principais dependências para

matplotlib Incluindo freetype e pyparsing. Certifique-se de que você tem esses pacotes pré-instalados em seu sistema se
você estiver usando quaisquer outros métodos de instalação além dos citados na próxima seção. Você pode
obter mais informações sobre o
matplotlib biblioteca de seu site oficial ( http://matplotlib.org/ ).
Configurando matplotlib no Windows
Antes de instalar matplotlib no Windows, certifique-se de que você tem o seu sistema operativo Windows com a versão
mais recente da distribuição 2.x do Python. Dentro Capítulo 1 , Introdução ao Python e Arduino, instalamos Setuptools
para baixar e instalar pacotes Python adicionais. Certifique-se de que você tem Setuptools instalado e configurado
corretamente. Antes de avançar ainda mais, teremos que instalar as dependências para matplotlib.

Abra o prompt de comando e use o comando a seguir para instalar o dateutil e

pyparsing pacotes:

> python_dateutil easy_install.exe

> pyparsing easy_install.exe

Depois de ter instalado com sucesso estes pacotes, baixar e instalar o pré-compilados NumPy pacote do http://sourceforge.n
. Certifique-se de que você escolha os arquivos de instalação apropriados para Python 2.7 e o tipo do seu
sistema operacional Windows.

Agora, o computador deve ter satisfeito todos os pré-requisitos para matplotlib. Baixe e instale o
pré-compilados matplotlib pacote do
http://matplotlib.org/downloads.html .

Neste processo de instalação, temos evitado o uso de Setuptools para NumPy e

matplotlib por causa de alguns problemas conhecidos relacionados à matplotlib no sistema operacional Windows. Se você pode
descobrir maneiras de instalar esses pacotes usando Setuptools, então você pode pular as etapas manuais anteriores.
Configurando matplotlib no Mac OS X
Instalação de matplotlib no Mac OS X pode ser difícil dependendo da versão do Mac OS X e da
disponibilidade de dependências. Certifique-se de que você tem Setuptools instalados como descrito
em Capítulo 1 , Introdução ao Python e Arduino. Supondo que você já tem Setuptools e pip, execute o
seguinte comando no terminal:

$ Pip sudo instalar matplotlib

Executar este comando irá levar a uma das três possibilidades seguintes:

instalação bem-sucedida da última matplotlib versão

Notificação de que os requisitos já estão satisfeitos, mas a versão instalada é mais antiga do que a
versão atual, que é de 1,3 no Erro momento durante a instalação do matplotlib pacote

Se você encontrar a primeira possibilidade, então você pode avançar para a próxima seção; caso contrário, siga as
instruções de solução de problemas. Você pode verificar o seu matplotlib versão usando os seguintes comandos no Python
prompt interativo:

> > > matplotlib importação

> > > matplotlib .__ version__

matplotlib Upgrading
Se você encontrar a segunda possibilidade, que afirma que a versão existente do
matplotlib é mais antiga do que a versão atual, use o seguinte comando para atualizar o
matplotlib pacote:

$ Sudo pip instalar --upgrade matplotlib

Vá até a seção seguinte no caso de você acabar com erros durante a atualização.

Resolução de problemas erros de instalação

Se você encontrar quaisquer erros durante o matplotlib instalação via pip, é mais provável que você está faltando
alguns pacotes de dependência. Siga estes passos, um por um para solucionar os erros.

Gorjeta

Após cada etapa, use um dos seguintes comandos para verificar se o erro for resolvido:

$ Pip sudo instalar matplotlib

$ Sudo pip instalar --upgrade matplotlib

1. Instale o Xcode da App Store da Apple. Abra Xcode e navegue até o Baixar
guia em Preferências .... Baixar e instalar Ferramentas de linha de comando a partir de

Preferências .... Esta etapa deve resolver quaisquer erros relacionados a compilação.

2. Instale homebrew usando o seguinte comando no terminal:

$ Ruby -e "$ (" $ (curvatura -fsSL

 https://raw.github.com/Homebrew/homebrew/go/install) ")"

3. Instale os seguintes pacotes usando homebrew:

$ Bebida instalar freetype $ bebida

instalar pkg-config

Se você ainda receber um erro com o freetype pacote, tentar criar um link para
freetype usando o seguinte comando:

$ Link bebida freetype

$ Ln -s / usr / local / opt / freetype / include / freetype2 / usr / local / include /
freetype

Se você receber quaisquer erros após executar as etapas anteriores, vá para o

matplotlib fóruns em http://matplotlib.1069221.n5.nabble.com/ para esses erros específicos.

Nota

Se você usar matplotlib no Mac OS X, você precisa configurar o backend desenho adequado, como mostrado
no seguinte trecho de código:

matplotlib importação
matplotlib.use ( 'TkAgg' '')

Você pode aprender mais sobre o desenho backends para matplotlib em

http://matplotlib.org/faq/usage_faq.html#what-is-a-backend .
Configurando matplotlib no Ubuntu
A instalação de matplotlib e as dependências necessárias é um processo muito simples no Ubuntu. Podemos
executar esta operação sem usar Setuptools e com a ajuda do gerenciador de pacotes do Ubuntu. O
seguinte comando simples deve fazer o truque para você:

$ Sudo apt-get install python-matplotlib

Quando solicitado a selecionar dependências, clique em sim instalá-los todos. Você deve ser capaz de encontrar o matplotlib
embalar em outras distribuições Linux populares também.
Traçando números aleatórios utilizando

matplotlib
o matplotlib biblioteca fornece um conjunto de funções relacionadas com a plotagem e métodos básicos através do pyplot estrutura.
o pyplot quadro contém funções para a criação de figuras, desenho parcelas, a criação de títulos, a criação de eixos, e muitos
métodos de plotagem adicionais. Uma das funções de importação fornecidas pelos pyplot é figura(). Isso inicializa uma tela
figura vazia que pode ser selecionado para o seu enredo ou um conjunto de lotes:

fig1 = pyplot.figure (1)

Você pode semelhante criar várias figuras especificando um número como parâmetro, ou seja,
Figura 2). Se uma figura com este número já existe, o método ativa a figura existente que, em seguida, pode
ser ainda utilizado para traçar. o matplotlib biblioteca fornece o enredo() método para criar gráficos de linha. o enredo()

método leva uma lista ou uma estrutura de dados de matriz que é constituída por inteiro ou números de ponto flutuante como entrada. Se

duas matrizes são usadas como entradas, enredo() utiliza-os como valores para o X

eixo e o y eixo. Se apenas uma lista ou matriz é fornecido, enredo() assume que seja os valores de sequência para o y
eixo e usos auto-gerado valores incrementais para o X eixo:

pyplot.plot (x, y)

O terceiro parâmetro opcional que é apoiado pelo enredo() método é para a cadeia de formato. Esses parâmetros ajudam os
usuários a alterar o estilo da linha e marcadores com cores diferentes. No nosso exemplo, estamos usando o estilo de linha
sólida. Então o enredo() função para o nosso enredo parece com isso:

pyplot.plot (x, y, '-')

o enredo() função fornece uma seleção em uma grande coleção de estilos e cores. Para encontrar mais
informações sobre esses parâmetros, use Python Socorro() função no
enredo() função de matplotlib:

> > > matplotlib importação

> > > ajuda (matplotlib.pyplot.plot)

este Socorro() função irá fornecer as informações necessárias para criar plotagem estilos com diferentes marcadores, estilos
de linhas e cores. Você pode sair deste menu de ajuda digitando q no prompt.

Agora, como temos explorado plotagem suficientemente, vamos criar o seu primeiro lote Python usando o seguinte trecho
de código. O programa que contém este código também está localizado na pasta de código deste capítulo com o nome plotBasic.py:
de importação matplotlib importação pyplot aleatório

x = intervalo (0,25)
y = [random.randint (0100) para r na gama (0,25)]
fig1 = pyplot.figure () pyplot.plot (x, y,
'-')
pyplot.title ( 'Primeiro Plot - inteiros aleatórios') pyplot.xlabel ( 'X Axis)
pyplot.ylabel (' Y ​Axis)

pyplot.show ()

No exercício anterior, foram geradas aleatoriamente um conjunto de dados para a y usando o eixo

randint () método. Você pode ver um gráfico que ilustra esses dados com o estilo de linha sólida em uma janela aberta
após a execução do programa. Como você pode ver no trecho de código, foi utilizado o adicional pyplot métodos tais
como título (), xlabel (), ylabel (), e enredo(). Estes métodos são auto-explicativos e eles são amplamente utilizados para fazer
suas parcelas mais informativo e significativo.

No final do exemplo, usamos um dos mais importantes pyplot métodos chamados mostrar().
o mostrar() método apresenta as parcelas geradas em uma figura. Este método não é obrigatória para exibir figuras
ao executar a partir do prompt interativo do Python. A imagem seguinte ilustra o grico de valores gerados
aleatoriamente usando matplotlib:
Plotagem dados de um arquivo CSV
No início do capítulo, criamos um arquivo CSV a partir de dados Arduino. Nós estaremos usando esse SensorDataStore.csv arquivo
para esta seção. Se bem se lembram, foram utilizados dois sensores diferentes para registrar os dados. Assim, temos duas
matrizes de valores, um a partir de um sensor digital e outra a partir de um análogo. Agora, no exemplo anterior, nós apenas
plotados um conjunto de valores para o y eixo. Então, como é que vamos traçar duas matrizes separadamente e de forma
significativa?

Vamos começar criando um novo programa de Python usando as seguintes linhas de código ou abrindo o plotCSV.py arquivo
da pasta de código deste capítulo:

csv importação
de matplotlib pyplot importação

i = []
mValues ​= [] pvalues
​= []

com aberto ( 'SensorDataStore.csv', 'r') como f:

leitor = csv.reader (f) = cabeçalho seguinte
(leitor, Nenhuma) para a linha no leitor:

i.append (int (linha [0])) pValues.append (flutuador

(fileira [1])) se fileira [2] == 'True':

mValues.append (1) else: mValues.append

(0)

pyplot.subplot (2, 1, 1) pyplot.plot (i, pvalues, '-')

pyplot.title ( 'linha de trama -' + cabeçalho [1]) pyplot.xlim ([1, 25])

pyplot.xlabel ( 'Eixo X') pyplot.ylabel ( 'Eixo Y')

pyplot.subplot (2, 1, 2) pyplot.bar (i,

mValues)
pyplot.title ( 'gráfico de barras -' + cabeçalho [2]) pyplot.xlim ([1, 25])
pyplot.xlabel ( 'Eixo X') pyplot.ylabel ( 'Eixo Y')

pyplot.tight_layout ()

pyplot.show ()

Neste programa, nós criamos duas matrizes de sensor de valores- pvalues e mValues -pela leitura do SensorDataStore.csv linha
de arquivo por linha. Aqui, pvalues e mValues representam os dados do sensor para o potenciômetro eo sensor de
movimentos, respectivamente. Uma vez que tivemos essas duas listas, nós plotados-los usando o matplotlib métodos.
o matplotlib biblioteca oferece várias maneiras de traçar diferentes matrizes de valores. Você pode individualmente
traçar-los em duas figuras diferentes, utilizando figura(), isso é, figura 1) e
Figura 2), ou traçar ambos em uma única parcela em que se sobrepõem uns aos outros. o pyplot
método também oferece uma terceira alternativa significativa, permitindo que vários lotes de uma única figura, através do subtrama
() método:

pyplot.subplot (2,1,1)

Este método é estruturado como subtrama (nrows, ncols, plot_number), que cria grelhas sobre as lona figura
usando linha e números de colunas, isto é, nrows e ncols
respectivamente. Este método coloca a trama na célula específica que é fornecida pelo
plot_number parâmetro. Por exemplo, através subtrama (2, 1, 1), criamos uma mesa de duas linhas e uma coluna e colocada
primeiro a subtrama na primeira célula da tabela. Do mesmo modo, foi utilizado o seguinte conjunto de valores para o
segundo sub-trama e foi colocado na segunda célula, isto é, a linha 2 da coluna e 1:

pyplot.subplot (2, 1, 2)

No primeiro subplot, temos utilizado o enredo() método para criar um lote utilizando o valor analógico vindo do potenciómetro, ou

seja, pvalues. Enquanto na segunda sub-trama, que criado um gráfico de barras, em vez de um gráfico de linha para apresentar os

valores digitais a partir do sensor de movimento. A funcionalidade gráfico de barras foi fornecida pela Barra() método. Como você

pode ver no trecho de código, nós utilizamos um adicional pyplot () método chamado

xlim (). o xlim ([x_minimum, x_maximum]) ou ylim ([y_minimum, y_maximum])

os métodos são usados ​para limitar a trama entre os indicados os valores máximos e mínimos de eixos particulares.

Antes de nós exibida estas subtramas na figura usando o mostrar() método, foi utilizado o
tight_layout () função de organizar os textos do título e etiqueta na figura. o
tight_layout () função é muito importante matplotlib módulo que se encaixam bem os parâmetros subtratamentos em uma figura.
Você pode verificar os efeitos deste módulo por comentar essa linha e executar o código novamente. A seguir mostra
imagem de tela estes subparcelas com rótulos e um título em uma figura objecto:
Plotagem em tempo real Arduino dados
No capítulo anterior, ao lidar com dados da GUI e Arduino, você deve ter notado que o código foi atualizar a interface com
cada novo valor que foi obtido a partir dos sensores Arduino. Da mesma forma, neste exercício, que será redesenhar o
enredo cada vez que receber novos valores de Arduino. Basicamente, estaremos traçando e atualizar um gráfico em tempo
real em vez de planejar todo o conjunto de valores do sensor como fizemos no exercício anterior. Nós estaremos usando o
mesmo circuito Arduino que você construiu nos exercícios anteriores. Aqui, vamos utilizar apenas a secção potenciômetro
do circuito para obter os valores dos sensores analógicos. Agora, antes de explicar os novos métodos utilizados neste
exercício, vamos primeiro abrir o arquivo do programa para este exercício. Você pode encontrar o arquivo de programa da
pasta deste capítulo; é nomeado plotLive.py. No código, alterar os parâmetros apropriados para a placa Arduino e executar o
código. Enquanto o código está sendo executado, gire o botão do potenciômetro para observar as mudanças em tempo real
na trama.

Na execução do programa, você receberá uma tela semelhante à seguinte imagem que mostra um gráfico a partir de dados do
Arduino em tempo real.

Pode-se fazer várias conclusões sobre a rotação botão do potenciômetro ou algum outro comportamento do sensor por apenas
olhando para a trama. Estes tipos de gráficos são amplamente utilizados no painel gráfico para aplicações de monitoramento em
tempo real. Agora, vamos tentar compreender os métodos que são usados ​no seguinte trecho de código para tornar isso
possível.
import sys, csv
de matplotlib importação pyplot pyfirmata
importação
de tempos numpy importação
importação sono como np

# Associado porta e bordo com porta pyFirmata =

'/dev/cu.usbmodemfa1321'' placa = pyfirmata.Arduino (porta)

# Usando iteração fio para evitar buffer overflow it = pyfirmata.util.Iterator (placa)

it.start ()

# Atribuir um papel e variável ao pino analógico 0 A0 = board.get_pin ( '' um:

0: i '')

# Inicializar pyplot.ion modo interactivo ()

pData = [0] * 25 fig pyplot.figure = ()

pyplot.title ( '' em tempo real potenciômetro leitura '') AX1 = pyplot.axes () L1, =
pyplot.plot (pData) pyplot.ylim ([0,1])

# plotagem de loop em tempo real,

enquanto True:
experimentar: 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 o enredo, exceto KeyboardInterrupt:

board.exit () pausa

O tempo real plotagem neste exercício é conseguido através de uma combinação de pyplot
funções íon(), desenhar(), set_xdata (), e set_data (). o íon() método inicializa o modo interactivo de pyplot. O modo
interativo ajuda a mudar dinamicamente o X e y
valores das parcelas na figura:

pyplot.ion ()

Uma vez que o modo interativo está definido para Verdade, a trama só será tirada quando o desenhar()
método é chamado.

Assim como o Arduino anterior interface exercícios, no início do código, nós inicializado a placa Arduino usando pyFirmata
e os pinos adicionais para obter os valores de sensor. Como você pode ver na seguinte linha de código, depois de
configurar a placa Arduino e pyplot modo interativo, nós inicializado a trama com um conjunto de dados em branco, 0 no
nosso caso: