Este é o nº um b>.', '
Este é o nº duas b>.', ' html>'] sopa = BeautifulSoup (''. join (doc)) # isso é dois apóstrofos, um após o outro, e não aspas duplas Isso carrega o arquivo chamado doc com o que um fluxo de web-página seria semelhante a longa corrente única de caracteres. Então sopa carrega as linhas em um arquivo que pode ser analisado pela biblioteca. Se você tivesse que digitar sopa de impressão, neste ponto, olharia o mesmo que os resultados de impressão digitando doc. No entanto, se você digitar soup.prettify print () você será recompensado com a página, refeito de uma forma mais legível. Este é apenas um exemplo do que Beautiful Soup pode fazer; Eu vou passar por isso mais quando chegarmos a programação do bot. Capítulo 5 ■ O Web Bot Como um aparte: o módulo re importar no exemplo anterior é usado para avaliar expressões regulares no texto. As expressões regulares, se você não estiver familiarizado com eles, são uma maneira extremamente versátil para pesquisar o texto e escolher cordas para fora e seqüências de caracteres de maneiras que podem não ser imediatamente óbvio para um leitor humano. Um regular expressão termo pode parecer jargão completo; um bom exemplo de uma expressão regular é a sequência (<= -?) \ w +, que procura por uma seqüência de caracteres em uma seqüência que segue um hífen. Para testá-lo, abra um prompt Python por digitação python e, em seguida, tipo re importação m = re.search ('(<= -?) \ w + "," pássaro-free') m.group (0) e você será recompensado com o "pássaro". Enquanto as expressões regulares são muito útil em termos de encontrar seqüências de caracteres no texto e cordas, eles são
também não é muito intuitivo e estão muito além do escopo deste livro. Nós não passar muito tempo com eles aqui. É do o suficiente para que você sabe que eles existem, e você pode gastar algum tempo aprendendo sobre eles, se eles lhe interessar.
Codificação com módulos Python Quando se trata de usar diferentes módulos Python quando codificar sua teia de aranha, você tem algumas opções. Muitos open-source aranhas já existem, e você pode tomar emprestado daqueles, mas é uma boa experiência de aprendizagem para codificar o aranha a partir do zero. Nossa aranha vai precisar fazer várias coisas, a fim de fazer o que precisamos que ele. Ele terá de iniciar conexões TCP e páginas de solicitação, analisar as páginas recebidas, download de arquivos importantes que ele encontra, e seguir os links que se trata através. Felizmente, a maioria destes são tarefas muito simples, por isso a nossa programação aranha deve ser relativamente simples. Usando o módulo Mecanizar Provavelmente, o módulo mais usado quando se trata de navegação na web automatizado, mecanizar é incrivelmente simples e incrivelmente complexo. É simples de usar e pode ser configurado com algumas linhas insignificantes de código, no entanto, também é embalado com características que muitos usuários não utilizam plenamente. É uma ótima ferramenta para automatizar tarefas como testes de web-site: se você precisa se logar em um local 50 vezes, com 50 combinações de usuário / senha diferentes, e, em seguida, preencher um formulário de endereço depois, mecanizar é a sua ferramenta de escolha. Outra coisa agradável sobre ele é que ele faz muito do trabalho, tais como o início de conexões TCP e negociar com o servidor web, por trás das cenas para que você possa se concentrar na parte de baixar. Para usar mechanize em seu script, você deve primeiro fazer o download e instalá-lo. Se você tem seguido ao longo, você ainda ter aberto um prompt de Python, mas você vai precisar de uma interface de linha de comando normal para este download e instalação processo. Aqui você tem duas opções: você pode sair do modo de entrada de Python, ou você pode abrir outro terminal sessão. Se você preferir ter apenas uma sessão terminal aberto, saia do prompt do Python em sua janela atual por digitando Ctrl + d, que irá voltar para o prompt de terminal normal. Por outro lado, se você optar por abrir outro sessão de terminal, você pode deixar a sessão em execução Python, e tudo que você digitou até agora ainda estará na memória. Independentemente da opção que você decidir, a partir de um prompt de linha de comando, digite wget http://pypi.python.org/packages/source/m/mechanize/mechanize-0.2.5.tar.gz quando isso terminar o download, descompacte o arquivo com tar -xzvf mecanizar-0.2.5.tar.gz e navegue para a pasta resultante, digitando cd. Em seguida, execute sudo python setup.py install Siga as instruções na tela, e mecanizar será instalado e pronto para uso.
Capítulo 5 ■ O Web Bot Analisando com Beautiful Soup Eu mencionei a análise anterior; Beautiful Soup ainda é o melhor caminho a percorrer. Se você não tiver feito isso, insira sudo apt-get install python-BS4 em um terminal e deixar que o gerenciador de pacotes fazer o seu trabalho. Ele está pronto para usar imediatamente depois. Como eu disse antes, uma vez que você baixar a página, Beautiful Soup é responsável por encontrar ligações e passá-los para a função usaremos para download, bem como deixando de lado os links que serão seguidas mais tarde. Como resultado disto, no entanto, verifica-se que o trabalho de encontrar ligações e determinar o que torna-se baixar principalmente um problema com cordas. Em outras palavras, links (e o texto contido dentro delas) são nada além de cordas, e em nossa busca para desvendar esses laços e segui-los ou transferi-los, nós vamos estar fazendo um monte de trabalho com seqüências de trabalho que vão desde lstrip (removendo o caractere mais à esquerda) para anexar para dividir e vários outros métodos da biblioteca string. Talvez a parte mais interessante de um bot web, afinal de contas, não são os arquivos que baixa; sim, é o manipulações que você tem que fazer para chegar lá. Baixando com a Biblioteca urllib A última parte do quebra-cabeça aqui é o urllib biblioteca especificamente, sua função URLopener.retrieve (). Esta função é usado para baixar arquivos, sem problemas e sem espalhafato. Vamos passar o nome do nosso arquivo e deixá-lo fazer seu trabalho. Para usar urllib, primeiro você deve importá-lo. Mudar para o terminal com seu prompt Python, se ele ainda está aberta, ou de início outra sessão digitando python. Em seguida, digite
urllib importação para torná-lo disponível para uso. A biblioteca urllib usa a seguinte sintaxe: image = urllib.URLopener () image.retrieve ("http://www.website.com/imageFile.jpg", "imageFile.jpg") onde o primeiro parâmetro enviado para a função URLopener.retrieve () é a URL do arquivo, e o segundo parâmetro é o nome do arquivo local que o arquivo será salvo como. O segundo, o parâmetro de nome de arquivo obedece arquivo Linux e convenções de diretório; se você lhe dá o parâmetro "../../imageFile.jpg", imageFile.jpg será salvo duas pastas -se na árvore de diretórios. Da mesma forma, passando o parâmetro "as fotos / imageFile.jpg" irá salvá-lo na pasta de fotos no interior do diretório atual (a partir do qual o script é executado). No entanto, a pasta já deve existir; recuperar () não criar o diretório.
Decidir o que fazer download Isso pode obter tipo de pegajoso, porque não é tanta coisa lá fora. Infelizmente (ou felizmente, dependendo do seu ponto de vista), um bom negócio do que é protegido por direitos autorais, por isso mesmo se você encontrá-lo gratuitamente, ele realmente não é legal apenas para fazer o download. Tanto faz você está procurando está lá fora. Isso, no entanto, é o tema para um livro completamente diferente. Por enquanto, vamos supor que você está indo ser à procura de informações livremente disponíveis, como todas as obras de Mark Twain, que são do domínio público. Que significa você provavelmente vai estar à procura de .pdf, .txt, e possivelmente até mesmo .doc ou .docx arquivos. Você pode até querer ampliar os parâmetros de pesquisa para incluir .mobi (Kindle) e arquivos .epub, bem como .chm. Estes são todos os formatos de arquivos legítimos que pode conter o texto de livros que você está procurando.
Capítulo 5 ■ O Web Bot Escolher um ponto de partida A próxima coisa que você vai precisar é um ponto de partida. Você pode estar inclinado a dizer apenas "Google !," mas com dezenas de milhões de resultados de pesquisa de uma simples busca por "Mark Twain", você provavelmente seria melhor ficar um pouco mais focado. Faça um pouco de bases de antemão, e salvar a si mesmo (e seu bot) horas de trabalho mais tarde. Se você puder encontrar um arquivo online de obras de Twain, por exemplo, que seria um excelente ponto de partida. Se você está à procura de música livre de downloads, você pode querer obter uma lista em conjunto de blogs que apresentam novos arquivos de música de up-andcoming bandas, porque muitos novos artistas canções dar afastado para fazer o download gratuito nesses blogs, a fim de promover a si e sua música. Da mesma forma, documentos técnicos que lidam com especificações IEEE rede provavelmente pode ser encontrada em uma técnica local, ou mesmo um governo, com muito mais sucesso do que uma ampla pesquisa Google. Armazenar seus arquivos Você também pode precisar de um lugar para armazenar seus arquivos, dependendo do tamanho do cartão SD do seu Pi. Esse cartão atua tanto como RAM e um lugar para armazenamento de arquivos, por isso, se você estiver usando um cartão de 32 GB, você vai ter muito espaço para arquivos .pdf. No entanto, um cartão de 4-GB pode encher-se muito rapidamente se você estiver baixando arquivos de filmes documentais livre. Então você vai precisar de um disco rígido externo USB drive-quer um disco rígido full-blown ou uma unidade flash menor. Mais uma vez, este é o lugar onde alguma experimentação pode vir a calhar, porque algumas unidades externas não vai funcionar bem com o Pi Raspberry. Porque eles não são particularmente caros nos dias de hoje, gostaria de comprar um ou dois queridos médias e
dar-lhes uma tentativa. Atualmente estou usando uma unidade de 8 GB flash Dane-Elec (mostrado na Figura 5-2), sem quaisquer problemas. comum para armazenar arquivos Figura 5-2. Flash drive comum (Uma nota sobre como acessar sua unidade de salto através da linha de comando: uma unidade ligada, como uma unidade uni dade flash está acessível no diretório / media; isso é, cd / media poderá ir para o diretório onde você você deve ver sua unidade listada. Você pode então navegar nele e acessar acessar sua conteúdo. Você vai querer configurar seu script Python para salvar arquivos em que Directory- / media / PENDRIVE, por exemplo, ou / media / EnglebertHumperdinckLov EnglebertHumperdinckLoveSongs. eSongs. Provavelmente a maneira mais fácil de fazer isso é para salvar seu script em um webbot.py diretório em seu disco rígido externo, e depois executá-lo de lá.)
Escrevendo o Python Bot Vamos começar a escrever alguns Python. O código a seguir importa os módulos necessários e usa a versão de Python de entrada (raw_input) para obter um ponto de partida (para o qual eu tenho anexado o "http: //" encontrados em cada endereço web). Em seguida, inicia um "navegador" (com aspas) com mechanize.Browser (). Este código, em sua forma final concluída, está listada no final de este capítulo. Também está disponível para download como webbot.py no site da apress.com. Capítulo 5 ■ O Web Bot Para iniciar o processo de escrever o seu bot, use seu editor de texto (ou Leafpad ou nano) e começar um novo arquivo, chamado webbot.py. Digite o seguinte: BS4 de importação BeautifulSoup mecanizar importação tempo de importação urllib importação import string start = "http: //" ("Onde //" ("Onde você gostaria de começar a procurar \ n") + raw_input BR = mechanize.Browser () r = br.open (iniciar) html = r.read () Mais tarde, pode precisar de um falso fa lso agente de usuário, dependendo dos sites que visitamos, mas este e ste código irá trabalhar para agora. Lendo uma String e extrair todos os links Uma vez que você tem um objeto de navegador, que é chamado br no código anterior, você pode fazer todos os tipos de tarefas com ele. Abrimos a página inicial solicitado ao usuário com br.open () e lê-lo lê -lo em uma longa seqüência, html. Agora nós podemos usar Beautiful Soup para ler essa seqüência e extrair todos os links de lá adicionando as seguintes linhas: sopa = BeautifulSoup (html) para ligação em soup.find_all ('a'): ('a'): print (link.get ('href')) Agora você pode executar o script para experimentá-lo. Salvá-lo e fechá-lo. Abra uma sessão de terminal e navegue para a mesma diretório no qual você criou webbot.py. Em seguida, se guida, digite python webbot.py para iniciar o programa e digite example.com quando ele pede por onde começar. Ele deve retornar o seguinte e, em seguida, sair: http://www.iana.org/domains/example Você leu com sucesso o conteúdo de http://example.com, extraiu as ligações (há apenas um), e impresso que apontam para a tela. Este é um começo impressionante. O próximo passo lógico é instanciar uma lista de links, e acrescentar a essa lista sempre Beautiful Soup encontra outro ligação. Você pode, então, iterar sobre a lista, abrindo cada link com outro objeto navegador e repetindo o processo. Procurando por e download de arquivos Antes de instanciar que lista de links, no entanto, há mais uma função, precisamos criá-lo que, na verdade, procura e download de arquivos! arquivos! Então, vamos procurar procurar o código na página para um tipo de arquivo. Nós provavelmente provavelmente deve ir para trás e perguntar que tipo de arquivo que estamos procurando, adicionando a seguinte linha de código no início do script, após a linha de partida: filetype = raw_input ("Que tipo de arquivo que você está procurando? \ n")
Capítulo 5 ■ O Web Bot ■ Nota Caso você esteja se perguntando, o \ n no final do raw_input corda em ambos os casos é um retorno de carro. Ela não fica impressa quando a linha é exibida. Em vez disso, ele envia o cursor para o início da próxima linha para esperar sua entrada. Não é necessário, ele só faz a saída de olhar um pouco mais bonita. Agora que sabemos o que estamos procurando, à medida que acrescentamos cada link para a lista de nós pode verificar para ver se é um link para um arquivo que nós queremos. Se estamos à procura de arquivos .pdf, por exemplo, podemos analisar o link para ver se ele termina em pdf. Se isso acontecer, nós vamos chamar URLopener.retrieve () e baixar o arquivo. Então abra sua cópia do webbot.py novamente e substituir o de bloco de código com o seguinte: para ligação em soup.find_all ('a'): linkText = str (link) se filetype em linkText: código de arquivo #download aqui Você notará dois elementos neste pequeno trecho de código. Primeiro, o str (link) pouco foi acrescentado. Beautiful Soup encontra cada link na página para nós, mas ele retorna como um objeto de link, que é uma espécie de sentido para código nãoSoup. Nós precisamos convertê-lo em uma corda, a fim de trabalhar com ele e fazer todas as nossas manipulações astutas. Isso é o que chamada o método str () faz. Na verdade, Beautiful Soup fornece um método para fazer isso por nós, mas aprender a analisar uma seqüência com a função str () é importante aprender aqui. Por uma questão de fato, é por isso que usamos a seqüência de importação linha no início do nosso código, para que possamos interagir com objetos de cadeia. Em segundo lugar, uma vez que o link é uma string, você pode ver como podemos usar Python em chamada. Semelhante ao C # 's String.Contains () método, chamada em Python simplesmente procura a cadeia para ver se ele contém a substring solicitado. Portanto, no nosso caso, se estamos à procura de arquivos .pdf, podemos procurar o texto do link para que substring, "pdf". Se ele tem, é um link em que estamos interessados. Testando o Bot Para tornar a testar o nosso bot mais fácil, eu criar uma página no http://www.irrelevantcheetah.com/browserimages.htmlde usar para teste. Ele contém imagens, arquivos, links e várias outras guloseimas HTML. Usando esta página, podemos começar com algo simples, como imagens. Então vamos modificar nosso código webbot.py e torná-lo parecido com este: mecanizar importação tempo de importação BS4 de importação BeautifulSoup import string urllib importação start = "http://www.irrelevantcheetah.com/browserimages.html" filetype = raw_input ("Que tipo de arquivo que você está procurando? \ n") BR = mechanize.Browser () r = br.open (iniciar) html = r.read () sopa = BeautifulSoup (html) para ligação em soup.find_all ('a'): linkText = str (link) fileName = str (link.get ('href')) se filetype em filename: image = urllib.URLopener () linkGet = "http://www.irrelevantcheetah.com" + fileName FileSave = string.lstrip (fileName, '/') image.retrieve (linkGet, FileSave) Capítulo 5 ■ O Web Bot Esta última seção do código que começa com o loop for requer alguma explicação, methinks. O loop for para através de todos os links que Beautiful Soup encontrados para nós. Então linkText converte os links para cordas para que possamos manipulá-los. Em seguida, converter o corpo do link (o arquivo real ou página para a qual o link aponta) para uma string como bem, e verificar para ver se ele contém o tipo de arquivo que estamos procurando. Se isso acontecer, nós acrescentá-la à URL base do site, dando-
nos linkGet. As duas últimas linhas tem que acontecer por causa da função de recuperar (). Como você se lembra, essa função leva dois parâmetros: a URL do arquivo que está baixando, e o nome local que gostaríamos de salvar o arquivo. FileSave leva o fileName encontramos anterior e remove o líder "/" do nome para que possamos salvá-lo. Se não fizéssemos este, o nome que iria tentar salvar sob seria por exemplo- / images / flower1.jpg. Se tentássemos salvar uma imagem com esse nome, Linux iria tentar salvar flower.jpg para a pasta / imagens, e em seguida, dar-nos um erro porque a pasta / imagens não existe. Ao remover o líder "/", o nome se torna images / flower1.jpg, e enquanto há uma pasta de imagens no nosso diretório atual (lembre-se que eu disse sobre a criação do diretório em primeiro lugar), o arquivo vai economizar sem incidentes. Finalmente, a última linha de código faz a descarga real, com os dois parâmetros já mencionei: linkGet e FileSave. Se você criar um diretório de imagens no diretório atual e, em seguida, executar este script, respondendo "jpg" para o arquivo Tipo de pergunta, o diretório de imagens devem encher-se com 12 imagens diferentes de flores. Simples, não é? Se, em vez disso, você cria um diretório de arquivos e resposta "pdf", você vai ter 12 (chato) PDFs diferentes na sua pasta de arquivos. Criando diretórios e instanciar uma lista Agora, existem mais dois recursos de que precisamos para adicionar para terminar este bot. Em primeiro lugar, não estamos sempre indo para saber o que os diretórios precisamos criar antes do tempo, por isso temos de encontrar uma maneira de analisar o nome da pasta a partir do texto do link e criar o diretório on the fly. Em segundo lugar, precisamos criar uma lista de links que apontam para outras páginas para que possamos, em seguida, visitar aqueles páginas e repita o processo de download. Se fizermos isso várias vezes, nós conseguimos um bot web real, seguindo os links e download dos arquivos que queremos. Vamos fazer a segunda tarefa de primeira instanciar a lista de links que mencionamos no final da seção que trata da lendo cordas e extração de links. Podemos criar uma lista no início do script, após as declarações de importação, e adicionar a ele como nós vamos. Para criar uma lista de nós simplesmente usar LINKLIST = [] Para adicionar a ele, nós adicionamos um bloco elif ao nosso script: se filetype em filename: image = urllib.URLopener () linkGet = "http://www.irrelevantcheetah.com" + fileName FileSave = string.lstrip (fileName, '/') image.retrieve (linkGet, FileSave) elif "htm" em filename: #covers ambos ".htm" e arquivos ".html" linkList.append (link) É isso aí! Se o nome do arquivo contém o tipo de ligação que está procurando, ele é recuperado. Se isso não acontecer, mas há uma "Htm" nele, ele é anexado ao LINKLIST-uma lista que podemos então percorrer, um por um, abrindo cada página e repetindo o processo de download. O fato de que nós vamos estar a repetir o processo de download muitas vezes deve fazer você pensar de um elemento de codificação: uma função -também chamado de método. Lembre-se, uma função é usado no código, se há um processo de você vai estar a repetir uma e outra vez. Torna-se para código mais limpo, mais simples, e também é mais fácil de escrever. Programmers, você encontrará, são pessoas muito eficientes. Se podemos codificá-lo u ma vez e reutilizá-lo, isso é sempre muito melhor do que digitando-a uma e outra e outra vez. É também uma enorme economia de tempo.
Capítulo 5 ■ O Web Bot Então, vamos começar a nossa função de descarga, adicionando as seguintes linhas para o nosso script webbot.py, após a LINKLIST = [] linha nós adicionamos apenas um pouco atrás: downloadFiles def (HTML, base, filetype, filelist): sopa = BeautifulSoup (html) para ligação em soup.find_all ('a'): linkText = str (link.get ('href')) se filetype em linkText: image = urllib.URLopener () linkGet = base + linkText FileSave = string.lstrip (linkText, "/") image.retrieve (linkGet, FileSave) elif "htm" em linkText: #covers tanto "html" e "htm" linkList.append (link)
Agora que temos a nossa função downloadFiles, tudo o que temos a fazer é analisar nosso linkText para obter o nome do diretório vamos precisar criar. Novamente, é a manipulação de cadeia simples, juntamente com a utilização do módulo os. O módulo os nos permite manipular diretórios e arquivos, independentemente de qual sistema operacional está sendo executado. nós Primeiro, podemos adicionar import os para o nosso script, e então nós podemos criar um diretório (se necessário), adicionando os.makedirs (). Você pode se lembrar que, a fim de simplificar a salvar, nós precisamos de ter um diretório local em nossa máquina que corresponde ao diretório da web em que os nossos arquivos de destino são armazenados. A fim de ver se precisamos de um diretório local, precisamos primeiro determinar que o nome do diretório. Na maioria (se não todos) casos, esse diretório será a primeira parte de nossa linkText; para exemplo, o nome do diretório em /images/picture1.html é imagens. Assim, o primeiro passo é percorrer a linkText novamente, à procura de barras da mesma forma que fizemos para chegar a base do nosso nome web-site, como este: slashList = [i para i, ind em enumerate (linkText) se ind == '/'] directoryName linkText = [(slashList [0] + 1): slashList [1]] O código anterior cria uma lista de índices em que barras são encontrados na cadeia de linkText. depois directoryName fatias linkText apenas a parte entre as duas primeiras barras. (/images/picture1.html é cortada para imagens de nosso exemplo anterior.) A primeira linha desse trecho tem alguma explicação porque é uma importante linha de código. linkText é uma string, e como tal é enumeráveis; isto é, os caracteres no seu interior pode ser iterada, um por um. slashList é uma lista do posições (índices) em linkText onde uma barra está localizada. Após a primeira linha preenche slashList, directoryName simplesmente agarra o texto contido entre a primeira e segunda barras. As próximas duas linhas simplesmente verificar para ver se existe um diretório que corresponda directoryName; se isso não acontecer, nós criá-lo. se não os.path.exists (directoryName): os.makedirs (directoryName) Isso conclui nossa função downloadProcess, e com ele o nosso bot web simples. Experimentá-lo apontando-o para http://www.irrelevantcheetah.com/browserimages.htmle pedindo tanto ".jpg", "pdf", ou "" tipos de arquivo txt, e vê-lo criar pastas e download de arquivos, tudo sem a sua ajuda. Agora que você começa a idéia, você pode ficar louco com isso! Criar diretórios, ressaca três (ou mais) níveis de profundidade, e veja o que seus downloads bot para você, enquanto você não está procurando! Metade da diversão é por vezes vendo o que é baixado quando você menos espera!
Capítulo 5 ■ O Web Bot O código final Aqui você pode ver o código final, longa que você está digitando, pouco a pouco, se você tem acompanhado ao longo como nós progrediu através do capítulo. Novamente, se você não quiser digitar tudo, ele está disponível em Apress.com como webbot.py. No entanto, eu recomendo que você o escreva, porque o código de aprendizagem pode ser muito mais eficaz se você digitá-lo em vez do que simplesmente copiando e colando-lo. mecanizar importação tempo de importação BS4 de importação BeautifulSoup re importação urllib importação import string import os def downloadProcess (html, base, filetype, LINKLIST): "Isso faz o download do arquivo real." sopa = BeautifulSoup (html) para ligação em soup.find_all ('a'): linkText = str (link.get ('href')) se filetype em linkText: slashList = [i para i, ind em enumerate (linkText) se ind == '/'] directoryName linkText = [(slashList [0] 1): slashList [1]] se não os.path.exists (directoryName): os.makedirs (directoryName) image = urllib.URLopener ()
linkGet = base + linkText FileSave = string.lstrip (linkText, "/") image.retrieve (linkGet, FileSave) elif "htm" em linkText: #covers tanto "html" e "htm" linkList.append (link) start = "http: //" ("Onde você gostaria de começar a procurar \ n") + raw_input filetype = raw_input ("Que tipo de arquivo que você está procurando? \ n") numSlash = start.count ('/') # número de barras no início necessidade de remover tudo após terceiro corte slashList = [i para i, ind em enumerate (start) se ind == '/'] #list de índices de barras if (len (slashList)> = 3): #if há 3 ou mais barras, cortado após 3 terceira = slashList [2] base = start [: terceiro] #base é tudo até a terceira barra outro: base = início BR = mechanize.Browser () r = br.open (iniciar) html = r.read () LINKLIST = [] lista de links #EMPTY
Capítulo 5 ■ O Web Bot imprimir "análise" + início downloadProcess (html, base, filetype, LINKLIST) por sobra em LINKLIST: time.sleep (0,1) #WAIT 0,1 segundos para evitar a sobrecarga do servidor linkText = str (leftover.get ('href')) print "Analisando" + base + linkText BR = mechanize.Browser () r = br.open (base + linkText) html = r.read () LINKLIST = [] downloadProcess (html, base, filetype, LINKLIST)
Resumo Neste capítulo, você tem uma boa introdução ao Python, escrevendo um bot web, ou aranha, que podem atravessar a Internet para você e download de arquivos que você achar interessante, talvez até mesmo enquanto você dorme. Você usou uma função ou dois, construído e adicionado a uma lista de objeto, e até mesmo fez algumas manipulação de cadeia simples. No próximo capítulo, vamos transição longe do mundo digital e interagir com um fenômeno muito físico, o clima.
Capítulo 6 A Estação Meteorológica Desde tempos imemoriais, o homem foi fascinado pelo clima, fazendo perguntas como: "Será que vai chover para as nossas colheitas? Será que vai neve, para que possamos ir esquiar? Será que um tornado levar a nossa casa para um país fictício povoado por sobrenatural mulheres e primatas aéreas com capacidade? Nós obter algum tipo de tempo a cada dia: O que é que vai ser hoje "? Previsão do tempo nem sempre tem sido uma busca científica. Pessoas ia rezar para os deuses da chuva para a chuva e para os deuses do sol para a luz do sol. Se a oração não funcionou, eles costumam visitar um profeta ou um vidente, que professavam a capacidade de olhar para o futuro e prever o caminho de um sistema de baixa pressão vindo (embora não com essas palavras em particular, é claro). Gradualmente, a ciência por trás o tempo foi descoberto, e nós já não teve que contar com uma pedra mágica para um previsão. (Veja a Figura 6-1). As pessoas frequentaram a escola para se tornar meteorologistas e aprender sobre frentes tempo, tempestade surtos e outras informações relacionadas com o clima ciência. Figura 6-1. A pedra tempo (imagem © 2010 Tom Knapp) Capítulo 6 ■ A Estação Meteorológica Através de todos esses avanços, uma estação meteorológica era necessária, uma maneira pequena, localizada de manter-se na atual condições. Mesmo pequenas estações meteorológicas normalmente dar velocidade e direção do vento, temperatura, umidade, e relativa pressão barométrica. Cada uma destas leituras, quando vistos em combinação ao longo de um dia ou dois, pode ajudar você prever o tempo para o futuro imediato. Claro, o Raspberry Pi é perfeito para criar esta aplicação weather-estação. Um monte de poder computacional é não necessária, mas a capacidade de interagir facilmente com uma pequena rede de sensores é. Alguns estão ligados ao Pi através I2C (Inter-Integrated Circuit), alguns são ligados através de modulação de largura de pulso (PWM), e alguns são simplesmente conectado para os pinos GPIO. Por simplesmente polling cada sensor, um a um em um estilo round-robin, podemos obter uma imagem precisa do que o tempo está fazendo em determinado momento. Vamos começar por reunir as peças necessárias para construir a nossa estação meteorológica. A Lista de Compras de Peças A estação meteorológica não ter um monte de peças, mas o aviso justo: alguns deles são um pouco mais caro do que você pensa, considerando o seu tamanho: • Raspberry Pi e adaptador de energia • bússola Digital / magnetômetro (https://www.sparkfun.com/products/10530) • codificador de eixo óptico (http://www.vexrobotics.com/276-2156.html) • sensor de pressão barométrica (https://www.adafruit.com/products/1603) • Termômetro Digital (https://www.adafruit.com/products/1638) • pequeno placa de ensaio (https://www.sparkfun.com/products/9567) • eixo quadrado de loja de ferragens • Pinwheel ou dispositivo semelhante a um leque semelhante • Susan preguiçoso rolamento • placa de madeira fina • tubo de PVC com tampa, de cerca de 12 polegadas de comprimento, 1-2 polegadas de diâmetro • fios de ligação Diversos, cola, parafusos Usando o protocolo de I2C Este projeto aproveita o protocolo I2C para se comunicar com sensores de umidade e pressão que você vai adicionar ao Pi. Embora seja um protocolo relativamente simples, ele pode ficar um pouco confuso, por isso é melhor para analisá-lo rapidamente antes começamos a construção da estação. I2C permite que um grande número de dispositivos para se comunicar em um circuito usando apenas três fios: uma linha de dados, um relógio linha, e um fio terra. Cada dispositivo é chamado de nó, e geralmente há um nó mestre e muitos escravos. Cada nó escravo tem um endereço de 7 bits, como 0x77 ou 0x43. Quando o nó mestre necessita de comunicar com um determinado escrava, começa por transmitir um pouco "start", seguido do endereço do escravo, na linha de dados. Isso escravo responde com o reconhecimento, enquanto todos os outros escravos ignorar o resto da mensagem e voltar a espera para a próxima pulso endereço a ser transmitida. O master e slave comunicar uns com os outros, em seguida, muitas vezes alternando entre transmitir e receber os modos até toda a informação tenha sido transmitida.
Capítulo 6 ■ A Estação Meteorológica I2C tem sido referido como "o protocolo de série em esteróides", e isso é mais frequentemente usado em aplicações onde velocidade não importa e o custo das peças deve permanecer baixa. O Raspberry Pi tem dois pinos, # 3 e # 5, que são pré-configurado para ser SCL (relógio) linhas SDA do protocolo I2C (de dados) e, respectivamente, para que ele possa se comunicar facilmente com dispositivos I2C. Dois dos dispositivos que nós estaremos usando (o barómetro / altímetro e o magnetômetro) são dispositivos I2C, por isso vamos precisar configurar o Pi para fazer funcionar o protocolo I2C. Comece editando o arquivo / etc / módulos, digitando sudo nano / etc / modules e adicione as linhas i2c-bcm2708 i2c-dev até o fim do arquivo, salvá-lo quando você está feito. Em seguida, reiniciar o Pi com sudo shutdown -r now. O Pi também tem um utilitário I2C que faz com que seja possível ver os dispositivos que estão conectados no momento. Para instalá-lo, digite sudo apt-get install python-smbus sudo apt-get install I2C-ferramentas Você também pode precisar de editar o seu arquivo de lista negra, se você tiver um. O arquivo blacklist.conf é usado pelo kernel do Pi para impedi-lo de carregar módulos desnecessários, e pode existir apenas em versões anteriores do OS Raspbian. Mais tarde versões não tem nenhum módulos bloqueados. Veja se /etc/modprobe.d/raspi-blacklist.conf existe; se isso acontecer, comentário as duas linhas seguintes: #blacklist spi-bcm2708 #blacklist i2c-bcm2708 Eles estão lá para impedir que o kernel de carregar os módulos I2C, e nós precisamos de carregar esses módulos, por isso, comentá-las. Agora você pode executar a ferramenta de utilitário chamado I2C i2cdetect para garantir que tudo está funcionando e ver quais dispositivos estão conectado. Digite a seguinte linha: sudo i2cdetect -y 1 que deve exibir a tela mostrada na Figura 6-2. Figura 6-2. A ferramenta i2cdetect Capítulo 6 ■ A Estação Meteorológica Neste caso, não há dispositivos estão presentes, o que faz sentido, porque não temos conectado em qualquer ainda. Mas agora você tem as ferramentas necessárias instalado e funcionando corretamente. ■ Nota Se, por acaso, você não tem dispositivos conectados, mas nada está mostrando, experimente digitar sudo i2cdetect -y 0 em vez disso. A 1 ou 0 bandeira depende da revisão Pi acontecer de você ter. Se você tiver a revisão Pi 2, você vai usar o 1 de pavilhão; caso contrário, o 0 a bandeira deve funcionar. Usando um anemômetro Uma parte importante de qualquer estação meteorológica é o anemômetro, o dispositivo que mede a velocidade do vento, porque o vento velocidade é um fator importante em qualquer previsão do tempo. Se for um dia frio (abaixo de 32 ° F ou 0 ° C, por exemplo), o vento velocidade desempenha um fator importante para o frio que se sente (o vento frio). De acordo com o vento do Serviço Nacional de Meteorologia
gráfico frio, um vento de 15 MPH a 15 ° F faz sentir como 0 ° F, e um vento de 20 MPH a 0 ° F faz sentir como 24 graus abaixo zero. A velocidade do vento é importante neste caso para determinar se suas extremidades vão congelar primeiro ou cair primeiro (ambos igualmente desagradável, se você me perguntar). Por outro lado, se não é particularmente frio, a velocidade do vento desempenha um papel na rapidez com que o próximo tempo fenômeno está vindo em você. Às 2 MPH, naquele dia ensolarado vai levar mais alguns dias para chegar até você; a 50 MPH, você tem apenas alguns minutos antes de o ciclone destrói sua casa. Um anemômetro pode ser um dispositivo relativamente complicado, com rolamentos e eixos e comutadores e assim por diante; nosso filho Por outro lado, é relativamente simples. Construindo o anemômetro Nós estaremos usando um codificador rotativo do eixo, um eixo de rotação, e algumas barbatanas para medir a velocidade do vento. O codificador do eixo rotativo que estamos usando de robótica Vex é composto por um disco de plástico com fendas espaçadas uniformemente ao redor sua circunferência. Quando a energia é aplicada, uma pequena luz brilha através das fendas no disco e em uma fotossensível receptor no outro lado. Por contagem do número de vezes que a luz é bloqueada pelo disco (ou, alternativamente, o número de vezes que a luz brilha através de uma fenda) em um determinado espaço de tempo, é possível determinar quão rápido o disco é fiação. É também possível determinar o número de vezes que o disco tenha rodado, e este é, de fato, como codificadores rotativos são usados frequentemente; se um codificador rotativo é ligado ao eixo de um robô, é uma boa forma de medir o quão longe as rodas ligado ao eixo que tenham viajado, por exemplo. Se o disco tem 90 ranhuras (como o nosso faz), sabemos que uma rotação completa do eixo (uma rotação completa da roda) é de 90 flashes de luz sobre receptor foto do encoder. Assim, podemos dizer ao robô, "Vá em frente 30 de fendas", e a roda vai avançar exatamente um terço da sua circunferência para a frente. Se sabemos o circunferência do disco / roda é de 3 pés, sabemos que o robô tem apenas um avançado pé. Isto pode parecer um monte de matemática desnecessário, mas é importante para você entender como o codificador opera. Uma vez que anexar as barbatanas para o eixo rotativo, que poderia (teoricamente) descobrir a velocidade do vento com base no circunferência das aletas e a velocidade do veio. No entanto, a minha experiência é que ele é realmente muito mais fácil simplesmente experiência com velocidades do vento conhecidos e incorporar essas velocidades em nosso programa, de modo que é o que vamos fazer. Façam isso, você vai precisar de um parceiro alguém que pode levá-lo ao redor em pré-determinado, sãs velocidades, enquanto você toma vento medições de velocidade. Isso significa velocidades de cerca de 5-20 MPH, não 80. Para criar o seu anemômetro, examinar sua loja de ferragem local até encontrar um pequeno eixo, 1/8-polegada quadrada que vai caber no buraco quadrado no codificador rotativo. (Ver Figura 6-3.)
Capítulo 6 ■ A Estação Meteorológica Figura 6-3. Eixo quadrado ■ Nota Como desta escrita, um eixo de 1/8 polegadas se encaixa perfeitamente no buraco do codificador rotativo. Em seguida, você vai precisar de um cata-vento ou algo similar. Eu usei a parte do moinho de vento de um kit de ciência que você pode comprar em sua loja local do ofício (http://amzn.to/1koelSW, por exemplo). Como você pode ver, o eixo se encaixa perfeitamente nas moinho de vento de furo, e a barbatana direcional atribui facilmente à volta do codificador. (Ver Figura 6-4.) Figura 6-4. Encoder com pás de vento ligado Todo o mecanismo tem de rodar; isto é, tem de ser ligado a um dispositivo que pode girar sobre um eixo, como um cata-vento, para que possamos determinar a direção do vento. Este é o lugar onde o conjunto de rolamento Lazy Susan entra em jogo.
Em primeiro lugar, cortar duas fendas na extremidade do tubo de PVC em que o codificador irá caber confortavelmente (como mostrado na Figura 6-5).
Capítulo 6 ■ A Estação Meteorológica Figura 6-5. Encoder no slot em tubo de PVC Coloque a tampa de PVC sobre a outra extremidade do tubo. Anexar um pedaço de luz de madeira para um lado do rolamento Lazy Susan, e, em seguida, tão perto do meio do eixo de rotação, como você pode, anexar o tubo de PVC e tampão com um parafuso de por baixo. A Figura 6-6 mostra um modo para determinar o centro do eixo de rotação. Figura 6-6. Determinar centro da plataforma Quando estiver pronto, você deve ter uma assembléia como a mostrada na Figura 6-7. 86
Capítulo 6 ■ A Estação Meteorológica Figura 6-7. Assembléia Anemometer Ligar o anemômetro para o Pi Agora precisamos ligar o anemômetro ao Pi e medir velocidades de rotação. Conecte o fio vermelho do encoder ao pino de alimentação do Pi (# 2), o fio preto ao GND (# 6), e o fio branco a um pino GPIO de sua escolha. Vamos usar pin # 8 para fins ilustrativos. Como mencionado anteriormente, este codificador funciona através do envio de um sinal de alta cada vez que uma fenda no disco passa um certo ponto. Sabemos que há 90 fendas no disco, de modo que todos os 90 sinais de alta uma rotação do eixo. Então, todos nós precisamos fazer é manter o controle dos altos e quanto tempo leva para obter 90 deles, e nós vamos ter velocidade de rotação ao longo do tempo. Se nós controlar o tempo em segundos (como veremos quando utilizando a biblioteca de tempo), nós vamos ter rotações por segundo. Assim, o código de leia nossa encoder deve ser algo como isto: tempo de importação importação RPi.GPIO como GPIO GPIO.setmode (GPIO.BOARD) GPIO.setup (8, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) prev_input = 0
Total = 0 atual = time.time () 87
Capítulo 6 ■ A Estação Meteorológica while True: entrada = GPIO.input (8) if ((não prev_input) e entrada): print ("giro") no total = Total + 1 prev_input = input se == total de 90: print (1 / (time.time () - atual)), "revoluções por segundo" Total = 0 atual = time.time () Tudo interessante aqui acontece no loop while. Desde que começamos definindo o prev_input a 0, a 1 (alto) como insumo significa que o disco está girando. Nesse caso, incremento total definido prev_input a entrada, e continuar o ciclo depois de verificar para ver se chegamos a 90 ALTO ainda. Se temos, isso significa que temos ido exatamente uma revolução, para que possamos calcular e revoluções de impressão por segundo (RPS) e redefinir total e atual. Para testar esta código de encoder, ligue os fios ao seu Pi, executar o script, e girar manualmente a roda de codificador. Você deveria ver 90 iterações da palavra "transformar" e, em seguida, uma linha com RPS exibido. Correlacionando rotações por segundo com velocidade do vento Se o codificador está funcionando como deveria, o único passo à esquerda é correlacionar rotações por segundo com a velocidade do vento, e o maneira mais fácil de fazer isso é com um amigo e um carro. Com o anemômetro realizada fora da janela e sua Pi ligado a seu laptop através de uma rede ad-hoc (veja o quadro), têm o seu amigo dirigir por alguns minutos a 5 MPH enquanto você executa o roteiro encoder; repita o processo em 10, 15 e 20 MPH até que você tenha dados suficientes para se correlacionam velocidade do vento com RPS. Quando eu dirigi ao redor com meu anemômetro pendurado para fora da janela, eu tenho as leituras RPS apresentados na Tabela 6-1. Tabela 6-1. MPH correlacionada à leitura RPS utilizando um anemômetro MPH RPS 5 5.8 10 9.23 15 10,8 20 11,7 A correlação de MPH para RPS é, obviamente, uma relação logarítmica, o que significa que podemos usar um pouco de álgebra (EEK!) para calcular a velocidade do vento com base em rotações por segundo. Se você traçar esses valores em um gráfico, você começa a Figura 6-8.
Capítulo 6 ■ A Estação Meteorológica Figura 6-8. RPS vs. MPH Como você pode ver a partir da equação, a relação entre rotações por segundo e velocidade do vento é um logarítmica, não linear, um. Então nós vamos ter que usar a função logarítmica inversa, ou e x, para resolver para a velocidade do vento em termos de rotações por segundo. Eu não quero aborrecê-lo com a matemática, então basta ter a minha palavra de que velocidade do vento = e ((y + 0,95) /4.3) Nós vamos ser capazes de substituir esse cálculo em nosso programa final, como você verá em breve.
LIGANDO SEU PI para o seu laptop através de uma rede AD-HOC Se você é como eu, a maior parte do trabalho que eu faço com o meu Pi é decapitado-I SSH (Secure Shell) para ele ou executar um VNC (Virtual Servidor Network Computing), se eu preciso ver o desktop, mas eu normalmente não têm um monitor, mouse ou teclado ligado a ele. Isso funciona bem se você estiver conectado à sua rede doméstica, por exemplo, mas o que se não há nenhuma rede em torno de? Felizmente, a criação de uma rede ad-hoc com fio entre o Pi e um laptop é bastante simples. Um ad-hoc é simplesmente uma conexão de rede entre o Pi e outro computador, tal como o seu laptop, sem router ou hub entre eles. A maneira mais fácil de configurar isso é tomar nota do seu endereço IP estático do Pi e ajustar porta Ethernet do seu laptop para se comunicar com esse endereço. Vamos dizer que seu Pi tem o endereço 192.168.2.42. Use um cabo Ethernet curta para conectar o Pi directamente à porta Ethernet de seu laptop. Agora vá em configurações de rede do seu laptop. Chances são o seu computador está configurado para receber um endereço automaticamente a partir do roteador via DHCP (Dynamic Host Controle Protocolo). Mude esse método para Manual, e dar um endereço que coincide com porta de rede do seu computador sub-rede do Pi. No nosso exemplo, um bom endereço seria 192.168.2.10. Se há pontos para isso, preencher o sub-
Capítulo 6 ■ A Estação Meteorológica máscara (255.255.255.0 funcionará neste exemplo) e do gateway padrão (192.168.2.1 neste caso). Se necessário, reinicie o seu computador ou reiniciar o seu gestor de rede. Agora você deve ser capaz de fazer login em sua Pi-conectado diretamente através de uma conexão padrão de terminal: ssh -l 192.168.2.42 pi e você pode trabalhar exatamente como você faria em sua rede doméstica. Ligar o Compass Digital A bússola digital que vamos usar neste projeto tem uma finalidade: para que possamos saber que direção o vento está soprando. O que estamos usando, o HMC5883L, usa o protocolo I2C, para se certificar que você está familiarizado com as informações no seção "Usando o protocolo I2C" anteriormente neste capítulo, antes de continuar. Comece soldando os cabeçalhos do sexo masculino que veio com ele para o conselho de fuga HMC. A orientação é com você; se você pretende torná-lo autônomo, você pode querer os cabeçalhos voltado para cima, de modo que eles são fáceis de acessar. Se, por outro lado mão, você está pensando em ligar o chip em uma placa de ensaio, por todos os meios solda-los para baixo, para que possa facilmente conectar toda a unidade em sua placa. Uma vez que os cabeçalhos são soldada à placa, conecte os pinos no seu Pi com jumpers. VCC e GND ir para o # 2 e # 6 pinos de Pi, respectivamente, e SDA e SCL ao do Pi # 3 e # 5 pinos. Agora você está pronto para usar a biblioteca smbus para ler a bússola, usando um pouco de matemática (eek!) para calcular o rolamento com base na x- sentiu e valores y. Agora seria um bom momento para usar a ferramenta i2cdetect mencionado anteriormente para se certificar de que você pode ler a bússola. Executar a ferramenta digitando sudo i2cdetect -y 0 (ou 1) e você deve ver o chip listada com o endereço 0x1e. (Ver Figura 6-9.) Figura 6-9. Visualizando a bússola 'endereço I2C Se ele não aparecer, verifique novamente as conexões. (O outro endereço que você vê listados na Figura 6-9, 0x60, é
outro dispositivo I2C eu tinha ligado para o meu Pi). Quando ele aparece, iniciar um novo script Python para ler a partir do dispositivo. Nós vamos usar ferramentas I2C da biblioteca smbus para ler e escrever para o sensor. Em primeiro lugar, começar um diretório em seu Pi para manter tudo de seu código-estação meteorológica junto digitando cd ~ tempo mkdir cd tempo
Capítulo 6 ■ A Estação Meteorológica Agora que você criou um diretório de tempo em sua pasta pessoal e já navegou no seu interior, digite o seguinte código em seu novo script Python: smbus importação matemática importação ônibus = smbus.SMBus (0) address = 0x1e read_byte def (ADR): retorno bus.read_byte_data (endereço, adr) read_word def (ADR): Alto = ônibus. read_byte_data (endereço, adr) baixo = bus.read_byte_data (endereço, adr + 1) val = (alta << 8) + baixa retornar val read_word_2c def (ADR): val = read_word (ADR) se (Val> = 0x8000): voltar - ((65535 - val) + 1) outro: retornar val write_byte def (adr, valor): bus.write_byte_data (endereço, adr, valor) write_byte (0, 0b01110000) write_byte (1, 0b00100000) write_byte (2, 0b00000000) escala = 0,92 x_offset = -39 y_offset = -100 x_out = (read_word_2c (3) - x_offset) * escala y_out = (read_word_2c (7) - y_offset) * escala rolamento = math.atan2 (y_out, x_out) Se rolamento <0: rolamento + = 2 * math.pi print "Rolamento:", math.degrees (rolamento) Depois de importar as bibliotecas corretas, este script configura funções para ler e escrever para o endereço do sensor de usando a biblioteca smbus. O read_byte funções (), read_word (), read_word_2c (), e write_byte () são todos usados a ler e escrever valores (tanto bytes individuais ou valores de 8 bits) para o endereço I2C do sensor. Os três write_byte (linhas) escrever os valores de 112, 32 e 0 ao sensor para configurá-lo para a leitura. Estes valores são normalmente listada nos dados folha que vem com um sensor de I2C. Capítulo 6 ■ A Estação Meteorológica ■ Nota Você também pode ter notado que muitas vezes quando você compra uma placa de fuga ou de qualquer Adafruit Sparkfun, essas empresas têm exemplo de código disponível para esse sensor. Confira no link "Documentação" em cada site sempre que você compra uma parte deles. Como qualquer programador irá dizer-lhe: se o trabalho já foi feito, não há precisa reinventar a roda. Também não há vergonha em usar código pré-existente se ele resolve o seu problema para você. O script, em seguida, lê os valores atuais dos xe do eixo y leituras da bússola e calcula os sensores de rolamento com atan2 da biblioteca de matemática () (tangente inversa) função, primeiro convertendo-a em graus com a biblioteca de graus () função. Os valores x_offset e y_offset, no entanto, estão sujeitos a alterações, dependendo do seu atual localização geográfica, e a melhor maneira para determinar esses valores é o de simplesmente executar o script. Execute o script, de preferência com uma bússola de trabalho nas proximidades, e comparar as leituras que você começa a bússola leituras. (O lado da placa com os cabeçalhos soldadas é a direção na qual a placa é "pontudo".) Você pode
ter de ajustar o bit deslocamentos por pouco para a obter o rolamento para registrar corretamente. Uma vez que é configurado, você tem uma maneira de medir a direção do vento; vamos montar a bússola para eixo de rotação do anemômetro para que possamos ler a direção quando montar a estação meteorológica final. Ligar a temperatura / umidade Sensor O sensor de temperatura e umidade que estamos usando, o Sensirion SHT15, é uma das peças mais caras nesta compilação. No entanto, é também muito fácil de trabalhar, porque não há nenhum protocolo I2C envolvido. Primeiro você vai precisar para soldar o incluídos cabeçalhos para ele. Como a bússola, a orientação dos cabeçalhos é com você. I tendem a soldar com cabeçalhos a placa virada para cima, para que eu possa ver o que cada pino é como eu ligar os fios de ligação para ele. Claro, se eu vou ligar o unidade em uma placa de ensaio, isso significa que eu não posso ler os pinos, mas essa é a troca. Uma vez que você soldadas os cabeçalhos, execute os seguintes passos: 1. Conecte o pino VCC ao pino 5V do Pi (# 2). 2. Conecte o pino GND para o Pi pin # 6. 3. Conecte o pino CLK ao pino # 7. 4. Conecte o pino de dados para o pino # 11. ■ Nota Com os pinos marcados DATA e CLK, seria um erro compreensível a pensar que este conselho é executado no I2C protocolo, mas isso não acontece. Os pinos são apenas rotulado dessa forma. Para trabalhar com este sensor, você terá que instalar a biblioteca rpiSht1x python por Luca Nobili. Dentro de sua diretório do tempo (ou onde quer que você está trabalhando em seu código de estação meteorológica), baixar a biblioteca rpiSht1x digitando wget http://bit.ly/1i4z4Lh --no-check-certificado ■ Nota Você precisará usar o "--no-check-certificado bandeira" porque eu tenho o link encurtado usando o link-encurtamento serviço bitly.com para tornar mais fácil para você digitar. Normalmente, quando você baixar um arquivo usando wget, ele só salva para o diretório atual, mas mudar o nome do link usando bitly.com pode levar a um comportamento estranho quando descarga. Esta bandeira corrige esse problema.
Capítulo 6 ■ A Estação Meteorológica Quando é feito o download (que não deve demorar muito, considerando que é apenas um download 8 KB), você vai precisar renomeá-lo para que você pode expandi-lo. Renomeie- o arquivo baixado, digitando mv 1i4z4Lh rpiSht1x-1.2.tar.gz e em seguida, expanda o resultado digitando tar -xvzf rpiSht1x-1.2.tar.gz Em seguida, cd para o diretório resultante (cd rpiSht1x-1.2) e prazo sudo python setup.py install Você tem agora a biblioteca disponível para você, então vamos experimentá-lo. Com seu SHT15 ainda ligado, como definido anteriormente, escreva o seguinte código: de importação sht1x.Sht1x Sht1x como SHT1x dataPin = 11 clkPin = 7 sht1x = SHT1x (dataPin, clkPin, SHT1x.GPIO_BOARD) temperatura = sht1x.read_temperature_C () Umidade = sht1x.read_humidity () ponto de orvalho = sht1x.calculate_dew_point (temperatura, umidade) temperatura = temperatura * 9/5 + 32 #use isso se você gostaria de sua temperatura em graus F print ("Temperatura: {} Umidade: {} Ponto de Orvalho: {}". format (temperatura, umidade, ponto de orvalho)) Salve esse código como sht.py e executá-lo com sudo python sht.py. O script usa as funções definidas no Adafruit script do read_temperature_C (), read_humidity (), e calculate_dew_point () - para obter os valores atuais a partir do sensor, o que temos conectado aos pinos 7 e 11. Em seguida, ele executa uma conversão rápida para aqueles de nós que não utilizam o sistema métrico e exibe os resultados. Você deve obter uma linha com as suas condições atuais: Temperatura: 72,824 Umidade: 24,282517922 Ponto de Orvalho: 1,22106391724
Como você pode ver, é uma biblioteca bastante auto-explicativo. Muitas dessas bibliotecas começaram suas vidas como escrito para o Arduino se comunicar com eles, e felizmente eles desde que foi portado para rodar no Pi. (Veja a nota lateral com relação ao uso do código existente anteriormente.)
Ligar o Barômetro Talvez uma das partes mais interessantes da estação meteorológica é o chip barómetro BMP180, mesmo por que mudando a pressão do ar é um dos melhores indicadores, como o que o tempo vai fazer a seguir. Em geral, caindo pressão de ar indica uma tempestade no caminho e crescente pressão de ar indica bom tempo pela frente. Isso é um simplificação, é claro, mas que parece ser o caso. O chip BMP180 é executado no protocolo I2C, então você vai ter que conectá-lo até seus SDA e SCL pinos (pinos de Pi # 3 e # 5) como você fez com a bússola. Depois de soldar os cabeçalhos para o conselho, se conectar VCC e GND para os pinos # 1 e # 6, e, em seguida, SDA e SCL para os pinos # 3 e # 5, respectivamente.
Capítulo 6 ■ A Estação Meteorológica ■ Nota Você está se conectando de energia do chip para 3.3V do Pi, não a 5V. Você quer que o chip para ser executado em 3.3V lógica para que ele não tem a chance de danificar entradas 3.3V delicadas do Pi. Para se certificar que tudo está conectado corretamente, executar sudo i2cdetect -y 0 e verifique se o dispositivo aparece. Ele deve aparecer como endereço 0x77, como na Figura 6-10. Figura 6-10. I2cdetect que mostra os endereços e 0x77 0x1E em uso ■ Observação O 0x1e dispositivo na captura de tela na Figura 6-10 é a bússola conectado estamos usando. Mais uma vez, este dispositivo necessita de algumas bibliotecas externas para trabalhar. Neste caso, vamos usar excelente BMP085 da Adafruit bibliotecas. ■ Observação versão original do chip BMP180 foi o BMP085. Embora desde então tem sido substituído, o esquema e pinagem dos chips é o mesmo, então todas as bibliotecas escritos para o BMP085 também trabalhar para o BMP180. Para agarrar a biblioteca necessária, no seu tipo de terminal wget http://bit.ly/NJZOTr --no-check-certificado Como fizemos antes, nós vamos precisar mudar o nome do arquivo baixado para que possamos usá-lo. Neste caso, o que nós arquivo baixado é nomeado NJZOTr. Renomeá-lo digitando mv NJZOTr Adafruit_BMP085.py
Capítulo 6 ■ A Estação Meteorológica Não há nada para instalar aqui, para que possamos ir direto para usar a biblioteca para se comunicar com o chip. Em uma nova Script Python no mesmo diretório, digite o seguinte:
Adafruit_BMP085 BMP085 de importação bmp = BMP085 (0x77) # Você pode reconhecer o endereço I2C aqui! temp = bmp.readTemperature () temp = temperatura * 05/09 + 32 #if você não está em um dos 99% dos países que utilizam Celsius pressão = bmp.readPressure () altitude = bmp.readAltitude () print "Temperatura: % .2f F "% temp print "Pressão: % HPa .2f "% (pressão / 100,0) print "Altitude: % .2f "Altitude% Como o roteiro para o sensor de temperatura fez, este pouco de código usa a biblioteca de pré-escrita e suas funções para ler os valores necessários a partir do chip de barômetro. Ao executá-lo, você deve obter algo como a Figura 6-11. Figura 6-11. Saída de sensor de pressão BMP180 Agora você pode ler a partir de todos os seus sensores, por isso é hora de colocar tudo junto!
Ligação dos Bits Uma parte importante da construção de esta estação do tempo está colocando tudo (ou pelo menos a bússola) em uma rotação plataforma para que você possa determinar a direção do vento. Como você pode ver na Figura6-12, eu coloquei todas as minhas fichas em um único placa de ensaio e conectá-lo ao Pi de modo que era mais fácil para mim para montar tudo (Pi e placa de ensaio) em um plataforma rotativa. Com uma plataforma de tamanho decente em seu preguiçoso Suzan rolamento, isso não deve ser um problema.
Capítulo 6 ■ A Estação Meteorológica Figura 6-12. Breadboarded fichas Observe a figura 6-12, você pode ter notado como eu o fiz,: eu usei os trilhos de alimentação que funcionam abaixo de um lado da placa para o lado positivo (+) e negativo (-) conexões, enquanto, por outro lado eu usei os trilhos para os dados (SDA) e relógio (SCL) linhas para as conexões I2C. É a maneira mais fácil que eu encontrei para anexar vários dispositivos I2C diferente do Pi, uma vez que partilham as linhas de relógio e de dados. Com o anemômetro montado no seu tempo de estação base, agora você pode anexar o Pi e o breadboarded bússola, sensor de temperatura, barómetro e batatas fritas. Por causa das curtas ligações do codificador rotativo, pode ser necessário para montar uma placa de ensaio adicional para o seu mastro anemômetro, como você pode ver na figura. Seu conjunto final pode parecer algo como a Figura 6-13. Fortaleça sua Pi, e você está pronto para receber atualizações meteorológicas.
Capítulo 6 ■ A Estação Meteorológica Figura 6-13. Concluída estação meteorológica Vamos escrever o código para que o Pi consulta cada sensor a cada 30 segundos e exibe os resultados na tela. Veja o código final. O código final O código final está disponível como weather.py de Apress.com. import os tempo de importação de importação sht1x.Sht1x Sht1x como SHT1x importação Rpi.GPIO como GPIO Adafruit_BMP085 BMP085 de importação smbus importação matemática importação Capítulo 6 ■ A Estação Meteorológica GPIO.setmode (GPIO.BOARD) GPIO.setup (8, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) ônibus = smbus.SMBus (0) address = 0x1e def read_byte (ADR): retorno bus.read_byte_data (endereço, adr) def read_word (ADR): Alto = bus.read_byte_data (endereço, adr) baixo = bus.read_byte_data (endereço, adr) val = (alta << 8) + baixa retornar val def read_word_2c (ADR): val = read_word (ADR) se (Val> = 0x8000): voltar - ((65535 - val) + 1) outro: retornar val def write_byte (adr, valor): bus.write_byte_data (endereço, adr, valor) def Checktemp ():
dataPin = 11 clkPin = 7 sht1x = SHT1x (dataPin, clkPin, SHT1x.GPIO_BOARD) temp = sht1x.read_temperature_C () temp = temperatura * 05/09 + 32 #if você quer graus F retorno temporário def checkHumidity (): dataPin = 11 clkPin = 7 sht1x = SHT1x (dataPin, clkPin, SHT1x.GPIO_BOARD) Umidade = sht1x.read_humidity () retorno umidade def checkBarometer (): bmp = BMP085 (0x77) pressão = bmp.readPressure () pressão = pressão / 100,0 pressão de retorno def checkWindSpeed () prev_input = 0 Total = 0 totalSpeed = 0 atual = time.time ()
Capítulo 6 ■ A Estação Meteorológica para i no intervalo (0, 900): entrada = GPIO.input (8) if ((não prev_input) e entrada): no total = Total + 1 prev_input = input se == total de 90: RPS = (1 / (time.time () - atual)) velocidade = math.exp (RPS (+ 0,95) /4.3) totalSpeed = totalSpeed + velocidade Total = 0 atual = time.time () velocidade = totalSpeed / 10 #AVERAGE velocidade em cada dez voltas velocidade de retorno def checkWindDirection () write_byte (0, 0b01110000) write_byte (0, 0b00100000) write_byte (0, 0b00000000) escala = 0,92 x_offset = 106 #use os deslocamentos você computadorizada yoffset = -175 #use os deslocamentos você computadorizada x_out = (read_word_2c (3) - x_offset) * escala y_out = (read_word_2c (7) - y_offset) * escala direction = math.atan2 (y_out, x_out) if (direção <0): + direção = 2 * math.pi Direcção = math.degrees (direção) direção de retorno loop de programa #main while True: temp = Checktemp () Umidade = checkHumidity () pressão = checkBarometer () velocidade = checkWindSpeed ()
direction = checkWindDirection () os.system ("clear") impressão "Condições Actuais" imprimir "----------------------------------------" print "Temperatura: ", Str (temp) print "Umidade: ", Str (umidade) print "Pressão: ", Str (pressão) imprimir "de velocidade do vento: ", Str (velocidade) print "Direção do Vento:", str (direção) time.sleep (30)
Capítulo 6 ■ A Estação Meteorológica Resumo Neste capítulo, você construiu uma estação meteorológica a partir do zero e instalados os sensores necessários para manter o controle sobre a vir-nos tempo, incluindo a pressão barométrica, temperatura, umidade, velocidade do vento, e até mesmo a direção do vento. Você aprendeu mais sobre a interface I2C e agora deve ter uma boa noção de como usar as funções do Python para repetir tarefas em um determinado intervalo. Você também já fez mais de fabricação aqui do que qualquer outro projeto até agora; agora você pode tirar uma pausa porque o próximo projeto, o servidor de mídia, não requer qualquer construção!
Capítulo 7 O Media Server O conceito por trás de um servidor de mídia é a capacidade de armazenar todos os seus arquivos de mídia de música e filmes em um centrolocalização, e depois transmiti-los a partir desse local para qualquer dispositivo em sua casa que você escolher. Estes dias, quase cada dispositivo de mídia (e alguns dispositivos não-mídia) pode ligar a uma rede senão a Internet, então, pelo menos, sua rede doméstica. Isto significa que todas essas máquinas, exceto, talvez, para o refrigerador, pode tornar-se clientes, streaming de arquivos de mídia a partir de um centro servidor. Esta é a linguagem padrão de rede; o computador que armazena Arquivossejam eles arquivos de mídia, planilhas ou páginas de web é chamado de servidor e os computadores que solicitam esses arquivos são chamados clientes. Quando isso acontece, o Pi é perfeito para agir como um servidor. Isso porque há muito pouco poder de computação necessário (um Arduino pode realmente ser um servidor de mídia, e é cerca de 100 vezes menos potente do que o Pi), e espaço de armazenamento é não é um problema, porque você pode transmitir arquivos de mídia a partir de qualquer dispositivo de armazenamento conectado, como um disco rígido externo. O Pi pode transmitir arquivos para qualquer dispositivo compatível. "Mas é uma caixa de Linux!" Eu ouço alguns de vocês gritando na parte de trás fila. "Eu preciso transmitir ao meu laptop Windows!" Não é um problema, o software usaremos para atuar como o servidor permite Linux servidores e clientes do Windows para jogar bem juntos. Em relação a seus arquivos de mídia, eu estou indo supor que você é, um cidadão cumpridor da lei íntegro que tenha pagado para todos dos seus filmes e música e acumularam uma coleção bastante o correto, legal caminho. Certo? Certo. Vamos começar com o peças que você vai precisar. A Lista de Compras de Peças Este projeto requer quase nenhuma peças. Tudo que você precisa é a sua Pi e um disco rígido USB externo grande o suficiente para armazenar todos os seus arquivos. O Pi deve reconhecer a maioria das unidades externas modernos, mas eu recomendo que se você comprar um carro para este efeito, você conecte-o ao Pi e se certificar que tudo funciona antes de iniciar a transferência de arquivos gigabytes
para que ele seja transmitido.
Usando uma unidade NTFS O disco rígido USB que você usa precisa ser formatado como uma unidade NTFS (New Technology File System). NTFS é um Formato Windows que muitas vezes requer algum tratamento especial, a fim de ser compatível com Linux. Foi o FAT32 formato mais usado frequentemente antes de NTFS e Linux e Unix não tinha problemas de leitura ou gravando a ele, mas FAT32 não consegue lidar com tamanhos de arquivo mais de 4 GB-limite facilmente ultrapassado por um arquivo de filme de alta definição. Assim, nós movemo-nos para o formato NTFS, que pode lidar com tamanhos de arquivo até 16 TB sem suar a camisa. FAT32 também teve problemas com um total conduzir tamanhos; dependendo do tamanho dos clusters de arquivo, ele só poderia formatar uma unidade até cerca de 127 GB. Formatos NTFS, sobre por outro lado, têm um teórico limite de tamanho superior de 256 TB com um cluster de 64 KB, obviamente, muito maior e mais aplicável aos tamanhos de arquivo e de unidade maiores de hoje. Os tamanhos dos arquivos são uma fonte comum de confusão com muitos utilizadores a criação de um servidor de arquivos / media pela primeira vez. Tabela 7-1 irá ajudá-lo a fazer algum sentido deles. Capítulo 7 ■ O Media Server Tabela 7-1. Tamanhos de arquivos comuns Tipo de arquivo Tipo de arquivo Tamanho médio Canção mp3 5 MB Vídeo de música mp4, avi, mpg 150 MB Filme def padrão mp4, avi, mpg 750 MB Filme def alta (~ 1080p) MP4, AVI, MKV, mpg > 1.5 GB Mantenha os tamanhos em mente como você olha para sua coleção de música e de vídeo atual e compras em torno de uma unidade em para armazená-los. Lembre-se também: 1024 KB é igual a 1 MB, 1024 MB equivale a 1 GB, 1.024 GB equivale a 1 TB. (Sim você pode rodada a 1000 na maioria dos casos; é uma coisa-2 binário 10 = 1024.) Por sorte, os preços estão caindo de forma constante de armazenamento, e você pode mais provável pegar uma unidade de 2 TB por menos de US $ 150 US. Porque a maioria dos discos comprados são pré-formatados com o formato NTFS, vamos ter certeza de sua Pi pode ler e escrever para ele, através da instalação de um programa chamado NTFS-3G. Abra um terminal, e instalá-lo digitando sudo apt-get install ntfs-3g NTFS-3G é uma fonte aberta, ler-escrever programa driver NTFS para Linux, Android, Mac OSX, e vários outros sistemas. Ele vem pré-instalado na maioria dos sistemas Linux, mas não o Pi (como esta escrito), que é por isso que você vai precisar para adicioná-lo. Uma vez que o NTFS-3G estiver instalado, conecte sua unidade em sua Pi. Você provavelmente vai ser saudado com uma janela pop-up pedindo o que fazer; basta selecionar "Abrir no Gerenciador de Arquivos" e continuar. Uma vez que você sabe que você pode lê-lo (exibindo seus arquivos), certifique-se de que você pode escrever para ele abrindo um terminal e criar um diretório (que é apenas para testes), como este: CD ../../ mídia de CD ls cd "My Book" (ou qualquer que seja a sua unidade é de uso nomeado ls para encontrar o nome) teste mkdir Se a pasta de teste aparece, você pode seguir em frente. Se não, certifique-se de que você instalou o NTFS-3G, e reinicie o Pi se necessário. Você pode ter notado o fato de que "My Book" está entre aspas no comando anterior. Isso porque arquivo enquanto nomes podem conter espaços, você precisa contabilizar os espaços quando você está usando a linha de comando. Se você precisar diretórios de mudança (CD) para uma pasta chamada My Book, apenas digitando a seguinte linha lhe dará um erro de arquivo não encontrado,
porque o sistema operacional procura por uma pasta chamada My e depois pára procurando: cd My Book A forma de contabilizar espaços em nomes de arquivos é que usar aspas o nome ou escapar do espaço com uma barra invertida, assim: Meu cd \ Livro Precisamos criar uma pasta de mídia no diretório / media do Pi, onde estaremos armazenando todas as nossas músicas e arquivos de filme. Nós podemos criar subdiretórios lá mais tarde, mas por agora nós só queremos ter certeza de que cada vez que inicializar o nosso Pi, o disco rígido externo vai se montado para a mesma pasta. Isso ocorre porque todos os nossos outros dispositivos (clientes) vai estar olhando para essa pasta quando configurá-los, e nós não queremos ter de reconfigurá-los para pedir um diferente pasta cada vez que inicializar o nosso Pi. Para criar essa pasta, faça-o como usuário root: sudo mkdir / media / Mídia
Capítulo 7 ■ O Media Server Para definir a pasta de mídia como um ponto de montagem, precisamos editar um arquivo chamado fstab e inserir informações da nossa unidade. Em primeiro lugar, precisamos de informações da nossa unidade. Em seu terminal, digite o seguinte comando: sudo blkid Isto irá listar todas as unidades, tanto virtuais e físicos, atualmente conectados ao seu Pi. Os resultados da minha blkid, por exemplo, se parecer com a tela mostrada na Figura 7-1. Figura 7-1. Resultados blkid Como você pode ver, o disco montado como / dev / sda1; "My Book", é o que nos interessa, e o que nós precisamos é de UUID que do disco (Universally Unique Identifier). Agora precisamos abrir o arquivo fstab, digitando sudo nano / etc / fstab Provavelmente haverá algumas linhas já no arquivo. Eles seguem este formato: Nome do dispositivo | Ponto de montagem | Sistema de arquivos | Opções | Opções de despejo | Opções de verificação do sistema de arquivos Nós precisamos adicionar a nossa unidade externa e ponto de montagem para o arquivo, com o sistema de arquivo correto e opções. Assim, como um exemplo, para uma unidade formatada em NTFS fictício, gostaria de acrescentar o seguinte (cada um separado por um tab): UUID = 39E4-56YT / media / Mídia ntfs-3g auto, user, rw, exec 0 0 A primeira entrada é UUID do seu carro, o segundo é a pasta que criamos anteriormente (que se tornará o monte ponto), o terceiro é o tipo de volume, e os três últimos são as permissões necessárias e opções padrão. Uma vez que você adicionou ao e salvou o arquivo fstab, montar todas as unidades em-lo digitando sudo mount -a (que deve forçar montar todas as unidades listadas na fstab se não está já montado), e você deve ouvir o seu spin para cima rígido externo. Em seguida, ver se ele montado corretamente para a pasta correta ao escrever o seguinte, que lista todos Atualmente unidades montadas: df -h Se tudo aparece corretamente, você pode passar para a próxima etapa do processo, a instalação de Samba.
Capítulo 7 ■ O Media Server
Instalando o Samba Como o site da Samba explica, "Samba é executado em plataformas Unix, mas fala para clientes Windows como um nativo. Permite um sistema Unix para mover-se em um Windows 'Vizinhança na rede' sem causar um rebuliço. Os usuários do Windows lata feliz arquivo de acesso e serviços de impressão sem saber ou se importar que esses serviços estão sendo oferecidos por um host Unix "O. nomear Samba vem do SMB (Server Message Block) protocolo, que é uma parte do CIFS (Common Internet File System) posto para fora por Microsoft em sua tentativa de obter junto com outros sistemas operacionais sem causar um outright motim. Este programa, então, é o que temos de instalar no Pi para que a sua coleção de caixas de Windows podem receber arquivos de mídia, bem como sua coleção de Macs e Linux caixas. Ele é pré-instalado em muitas distribuições Linux; o Pi, No entanto, não é um deles. A instalação é tão simples como escrever sudo apt-get install samba
SAMBA como uma ligação Era uma vez, todos os computadores jogou muito bem juntos. Networking foi simples, e os computadores comunicada facilmente através de linhas telefônicas, com baixas taxas de transmissão e pequenas mensagens. Se você precisava falar com outra computador, as chances são de que era mais de um BBS (Bulletin Board System) e não importa que sistema operacional você estavam usando. Se você não estava usando um BBS, as chances eram de que você estava executando o DOS como um sistema operacional, como foi o computador ao qual você estava falando. Foi um tempo mais simples. Em seguida, como computadores tem mais complexa, diferente sistemas operacionais surgiu. De um lado da parede divisória foi o império Unix, com seus reinos menores de Linux, Mac e BSD. Do outro lado do muro foi o grande império Microsoft, começando com o grande Rei DOS e seguida por seus herdeiros, os modelos do Windows a partir do Windows 1.01 para o Windows de hoje 8.1. Existia uma relativa paz entre os reinos; na verdade, os dois lados raramente falava, por isso não havia hostilidades. À medida que a Internet e outras redes interligadas cresceu, no entanto, tornou-se necessário para os dois lados trocar arquivos sem problemas e sem erros. O império Unix, sendo o menor dos dois, ajustado toda a sua sistemas operacionais para se tornar facilmente os clientes para um servidor Windows, como esta foi uma configuração comum em um configuração de rede. O lado do Windows, no entanto, se recusou a acreditar que ele nunca iria se inclinar para recebimento de arquivos a partir de um Servidor Unix e não fez nada para fazer este fácil ou mesmo possível. No entanto, servidores Unix e Linux têm proliferado, mesmo quando o número de clientes de desktop do Windows tem aumentou, e, portanto, eventualmente, tornou-se necessário para um cliente Windows para se comunicar e trocar arquivos com um servidor Unix com sabor. Enquanto isso poderia ser feito, não foi fácil, e normalmente exigido um super usuário com íntima conhecimento de protocolos e linguagens de redes. Digite Samba, um programa projetado para permitir que estes diferentes computadores para se comunicar facilmente com menos dores de cabeça por parte do usuário. Configurando Samba Uma vez Samba é instalado, é preciso configurá-lo. É uma boa idéia fazer um backup do arquivo de configuração atual antes de editá-lo para que você pode simplesmente restaurar deveria você regiamente estragar tudo. Para fazer isso, use o comando do Linux cp: sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.orig
Capítulo 7 ■ O Media Server Este comando copia o arquivo smb.conf para o arquivo smb.conf.orig no mesmo diretório. Ele precisa ser executado como sudo, porque a pasta / etc pode ser editado somente pelo usuário root. Quando isso é feito, você pode abrir o arquivo para edição, digitando sudo nano /etc/samba/smb.conf Você será saudado por uma configuração bastante grande arquivo-não deixe assustar. Nós só precisamos de alterar algumas configurações. O tamanho do ficheiro de configuração é um indicativo de como é adaptável Samba realmente; porque ele é usado em toda a Internet, como um servidor web e um servidor de arquivos, é importante que os usuários podem alterá-lo para atender às suas necessidades exclusivas. Nossas necessidades são
na verdade, bastante simples, e, portanto, não nos obrigam a mudar muitas coisas em configurações padrão do programa. A primeira definição que pode precisar de editar é o grupo de trabalho. O grupo de trabalho é simplesmente o domínio que o Samba servidor (o Pi) será uma parte. Como um servidor de home media, o domínio é o que o Windows chama um -sua "grupo de trabalho" rede doméstica. De acordo com as configurações globais, a mudança workgroup = WORKGROUP para o nome de seu grupo de trabalho local, se você tiver um. Se você não tem um set-up, deixe a configuração de grupo de trabalho como ele é. Em seguida, altere a string de servidor% h, remova o comentário da seguinte linha (através da remoção do hash tag): #wins apoio = no e alterá-lo para ler ganha apoio = yes De acordo com as configurações de rede, altere a linha de interfaces para ler ; as interfaces eth0 = wlan0 lo Deixar a seguinte linha como ela é: interfaces de ligar apenas = yes Um pouco mais abaixo, se for comentada, descomente security = user A última parte para a mudança é a seção Compartilhar Definições. Esta seção é onde você lista e configurar os campos e pastas que você deseja Samba para compartilhar com os outros. Desça até a parte inferior dessa seção, e adicione as seguintes linhas: [Mídia] = comentar Media Drive path = / media / Mídia browseable = yes guest ok = yes gravável = yes pública = yes disponível = yes criar mask = 0666 máscara diretório = 0777 Isso cria a parte de partilha de sua instalação Samba para coincidir com a unidade e pasta que criamos anteriormente. Isso também torna a pasta ver-capazes e cria a permissão correta compartilhamento para essa pasta.
Capítulo 7 ■ O Media Server Definindo permissões do Linux Permissões de arquivos Linux são uma besta interessante, e eles poderiam usar alguma iluminação, porque você é obrigado a vir entre eles, de alguma forma em suas viagens através do país Raspberry Pi na terra do Linux. Cada arquivo ou pasta tem três grupos de permissões associadas a ele: o proprietário, o grupo, e a todos os usuários do grupo. Essas permissões são ou r, w ou x, para leitura, escrever e executar. Quando você listar os arquivos em um diretório com ls -l você pode ver que cada item no diretório é precedida por uma linha como esta -rwxrwxrwx ou drwsr-xr-x O primeiro caractere é ou um - (hífen) ou ad, que lhe diz que é um arquivo ou um diretório. Em seguida, o permissões são listados em grupos de três, na ordem de proprietário, grupo e todos os usuários. Um arquivo listado como meio rwxrwxrwx que o proprietário do arquivo, os usuários pertencentes ao grupo que foi atribuída a esse diretório, e todos os usuários têm todos ler, escrever e executar permissões para esse arquivo. Se o ficheiro está listada como -rwxr-xr-x, por outro lado, isso significa que somente o proprietário tem permissões de gravação (pode escrever e salvar a ela.) Os outros dois grupos só podem ler o arquivo e executá-lo. Se você precisar alterar as permissões de um arquivo, você usar o comando chmod, o que pode ser feito de forma explícita ou com uma representação binária dessas permissões. Se você quiser fazê-lo explicitamente, as bandeiras utilizadas para cada grupo são u (proprietário), g (grupo), e o (todos os usuários). Por exemplo, se você quisesse alterar o arquivo -rwxrwxrwx a ser somente leitura para todos os usuários, você deve digitar chmod o-wx filename que mudaria sua listagem de diretório para -rwxrwxr--. Para fazer o inverso, você deve digitar
chmod o + wx filename para restaurar a gravação e executar permissões para todos os usuários. Se você preferir usar as permissões de binários, você pode fazer isso também. Basicamente, cada permissão tem um valor; r = 4, w = 2 e x = 1. Você adiciona os números inteiros para as permissões de cada grupo, e configurá-los dessa forma. Assim, um grupo permissões rwx seria um 7, e uma permissão rx seria um 5. Você precisa definir as permissões de cada grupo se você fizer dessa maneira; se um arquivo tem atualmente permissões -rwxrwxrwx, e você quer tirar permissões de gravação para o grupo e todos os usuários, você deve digitar chmod 755 filename Ele pode ficar um pouco confuso, mas uma vez que você trabalhou um pouco com permissões, tudo vai fazer sentido. Na nossa Arquivo de configuração do Samba, você definir as permissões de máscara e de diretório a -r-xr-xr-x e -rwxrwxrwx, respectivamente, que é o que precisamos a fim de transmitir todos os arquivos no diretório para os clientes.
Capítulo 7 ■ O Media Server Fixação do Bug Apostrophe Há uma outra coisa que você pode precisar editar na configuração do Samba padrão, e é algo que em meu parecer de você não deveria ter que fazer, mas é um erro e pode estragar tudo, se você perdê-lo. Olhe através de toda a descomentei linhas no arquivo e certifique-se de que não há apóstrofos solitários (') utilizadas como possessives no meio de uma linha. Se houver, exclua-os. Por exemplo, na parte inferior do arquivo, pode haver um apóstrofo no [CDROM] seção: ;[CD ROM] ; comment = CD-ROM do servidor Samba ; read only = yes ; = sem bloqueio ; path = / cdrom ; guest ok = yes Vê-lo lá na segunda linha? O problema é que o arquivo de configuração trata tudo após o apóstrofo como uma string literal, e não prestar atenção a qualquer coisa contida nele até que ele se depara com um outro único apóstrofo (mais uma vez, em uma linha uncommented) para fechar a string. Assim, mesmo se ele não estiver em uma seção da configuração do arquivo que você acho que você vai usar, ele ainda estraga o processo de configuração. Basta fazer a segunda linha neste exemplo parecido com este: ; comment = servidores Samba CD-ROM e ele deve funcionar bem depois disso. No meu arquivo smb.conf, havia três apóstrofos que tiveram de ser excluído antes a configuração funcionou correctamente. Se eles estão em uma linha comentada (precedido por um "#") estão totalmente ignoradas pela computador, para aqueles que você pode deixar em paz. Reiniciar o Serviço de Samba Quando você terminar de editar o arquivo de configuração, reinicie o serviço Samba, digitando sudo samba serviço restart Quando é instalado e funcionando novamente, ir para uma máquina Windows em sua rede doméstica e abrir um prompt de comando. No prompt, tipo net view \\ 192.168.xx.xxx (substituindo o endereço IP do seu Pi, obviamente). Você deve receber algo de volta como você vê na figura 7-2.
Capítulo 7 ■ O Media Server Figura 7-2. Vista Líquido de um compartilhamento de Samba de trabalho Conectando-se ao compartilhamento do Samba como um (rede) unidade compartilhada é, infelizmente, um pouco diferente em cada versão do Windows. Porque este livro é sobre o Pi, não o Windows, eu não posso entrar em todos os detalhes para cada versão usando uma interface gráfica. No entanto, se você não se importa usando uma interface de linha de comando, o comando para montar a mídia pasta em um compartilhamento Samba localizado na 192.168.2.42 no mesmo domínio é realmente muito simples. Parece que este net use z: \\ 192.168.2.42 \ Media * / USUÁRIO: pi / P: Sim Se tudo sobre o Pi está definido corretamente, você deve ver sua pasta de mídia montado como um Z: unidade. No entanto, o Windows 7 é notório por não querer jogar bem com Samba pastas compartilhadas. Se você está confiante de que você tem tudo configurado corretamente, mas ainda não pode ver o conteúdo da pasta (que você está recebendo um "acesso negado" erro, por exemplo), experimentá-lo com um sistema operacional diferente. Seu sistema operacional Windows pode ser o problema.
Conectando com Linux / OS X "Mas espere!" Eu posso ouvir alguns de vocês gritando fracamente na parte de trás da sala. "E se a gente quiser se conectar a nossa servidor com uma caixa de Linux ou Mac? " Bem, em primeiro lugar, se você estiver executando uma caixa de Linux em outro lugar em sua casa, você provavelmente não precisa de qualquer ajuda conectar a um compartilhamento do Samba. Se, entretanto, você estiver usando um Mac, é novamente muito fácil se conectar. A partir do seu Finder, clique em "Vá" e "Conectar ao Servidor". (Ver Figura 7-3.)
Capítulo 7 ■ O Media Server Figura 7-3. Menu de ligação Na janela que aparece, digite o endereço de e pasta compartilhada e clique em Conectar. (Ver Figura7-4.) Entre no nome e senha que você usa para fazer login no Pi na próxima janela, e a pasta deve montar como uma unidade compartilhada, acessíveis a partir de qualquer janela do Finder. Se acontecer de você estar usando Mavericks de Mac (OS 10.9), você também pode ter problemas conectando como "pi," mas você pode ser capaz de se conectar como "Convidado". Este é um problema com o Mavericks e, infelizmente, é não algo que eu possa facilmente resolver aqui. Figura 7-4. "Conectar ao Servidor" janela de diálogo em um Mac Agora você tem uma instalação funcional Samba você pode usar para compartilhar qualquer coisa que você colocar na pasta, e por que das permissões que você deu a ele, você não precisa se preocupar com acidentalmente excluir um arquivo na sua pasta de mídia a partir de outro dispositivo na rede. A única maneira de adicionar ou subtrair a partir da pasta compartilhada é do próprio Pi a pouco segurança para a sua música e filmes.
Capítulo 7 ■ O Media Server Onde está Python? Mas espera! Onde está o Python neste capítulo? Bem, não há Python neste capítulo. Este é um bom exemplo de um situação em que a programação não é necessário; as ferramentas que estão disponíveis são bons o suficiente apenas como elas são, e
às vezes é tão valioso para saber quando não programar, pois é para saber quando a programar.
Resumo Neste capítulo, você aprendeu um pouco sobre como os servidores e clientes operam, tanto na Internet e sobre a sua casa rede. Você aprendeu sobre como obter o Pi e outros computadores (nomeadamente Windows) para jogar bem juntos, e como compartilhar todos os seus arquivos de mídia em sua rede doméstica, acessível por qualquer dispositivo conectado, usando um compartilhamento de arquivos livre programa. No próximo capítulo, você aprenderá como usar o Pi para proteger sua casa rede não de hackers, mas a partir de intrusos físicas.
Capítulo 8 O sistema de segurança Home Vivendo em tempos modernos pode ser. . . bem, vamos enfrentá-lo. Pode ser, uma coisa estressante assustador. Os vilões, e os crimes que cometer, estão por toda parte. De acordo com o site do FBI Crime Statistics, havia cerca de 9 milhões de propriedade crimes cometidos nos Estados Unidos, em 2012, o ano mais recente para o qual existem estatísticas disponíveis. Os dias de vivendo em uma rua tranquila, onde os vizinhos se conheciam e você pode deixar sua porta destrancada enquanto você passou ao trabalho, estão muito longe. Felizmente, nós somos capazes de proteger as nossas casas e também para assistir as casas com câmeras de ambos ainda e vídeo de que são montados onde precisamos deles e capaz de live-streaming de vídeo que a qualquer dos nossos dispositivos sempre conectados, tais como os nossos laptops ou telefones. Podemos equipar nossa casa com sensores, como sensores de movimento e interruptores de viagem, e utilizar as informações recolhidas a partir desses sensores como um gatilho para executar determinadas ações. Se você está disposto a gastar o dinheiro, você pode instalar sistemas que fazem de tudo: proteger sua casa de fogo e os assaltantes para alertando-o para monóxido de carbono (CO) vazamentos. Quando isso acontece, o Raspberry Pi é perfeito para fazer todas essas coisas para um pouco mais barato do que uma rede inteira de câmeras de circuito fechado e o sistema de computador para executá-los. Não é um monte de poder de computação é necessário é pequenosuficiente e poder-mesquinho o suficiente para realmente ser instalado no local, ele pode tirar fotos de momentos importantes através da sua onboard câmera, e porque ele está conectado a uma rede doméstica pode alertá-lo quando algo está errado. Perfeito. Sim, você pode obter um cão de guarda. Na verdade, isso é o que muitas pessoas (alguns diriam normais de pessoas) fazer. Mas vamos dar um momento para considerar os prós e os contras de possuir um cão contra possuir um Raspberry Pi. Então, podemos começar a construir nosso sistema de segurança em casa com o Raspberry Pi. Cães como Segurança Cães (Canis lupus familiaris) são comumente conhecido como o melhor amigo do homem, e eles têm sido usados como cães de guarda para nigh em 10.000 anos. Eles são descendentes do lobo e vêm em todas as formas e tamanhos, desde o Chihuahua pint-sized para o gigante Great Dane. Um dos trabalhos do cão tem sido para proteger a casa contra intrusos. Eles são intensamente leal e protetor de seus membros da família humana e seu "den" e vai latir, e até mesmo ataque, os invasores. Para acompanhar esse comportamento, eles exigem comida, às vezes bastante dele. E, enquanto eles são muitas vezes bonitinho e fofinho, e grande em manter o seu pés quentes em noites frias do inverno, o fato de que eles têm para comer significa, infelizmente, que têm que eliminar o bem uma empresa fedido para todos os interessados. Os cães também são incapazes de ser atualizado. A última vez que eu tentei ligar um cabo USB para o meu cão, ela gritou. E Mesmo que os cães podem ser muito bonito quando enfiar a cabeça para fora da janela quando você está dirigindo pela estrada, você não pode atualizar os seus drivers ou usar um gerenciador de pacotes para baixar um programa de eliminação de gás mais eficiente. O resultado? Cães são grandes para vigiar a casa, mas eles têm algumas deficiências graves.
Capítulo 8 ■ O Sistema de Home Security Raspberry Pi como Segurança O Raspberry Pi (Rubus strigosus Pi) é comumente conhecido como o melhor amigo de o hobby-roboticista, e ele tem sido usado para fazer todos os tipos de projetos off-the-wall por pelo menos dois anos inteiros. Estes dispositivos são descendentes da Acorn Máquina RISC no início de 1980 e, como mencionado anteriormente, vêm em duas versões: a versão A e B. versão O Raspberry Pi não tem realmente um trabalho específico, mas como um computador, é bem sabido que ele vai seguir tudo instruções dado a uma falha. Se você programá-lo para encontrar todos os números primos entre 1 e 10000, ele irá fazê-lo; no Por outro lado, se você diga a ele para continuar a encontrar números primos até um porco voa em cima, ele continuará até que a computação seu processador queima ou até Porky cresce asas. Para fazer essas proezas incríveis, o Pi não tem que comer, nem tem que eliminar. O trade-off para a falta de metabolizar substâncias orgânicas é que o Pi não pode manter seus pés quente nas noites frias de Inverno. Você pode atualizar um Pi, no entanto, com o uso criterioso do sudo apt-get install comando. O Pi recebe um USB entrada, e pode ser programado para usar sensores para assistir a sua casa e seus jardins circundantes, e para alertá-lo se essas defesas são violados. Infelizmente falando da experiência pessoas dão-lhe muito olhares estranhos se você dirigir pela rua com seu Pi pendurar a cabeça para fora da janela, mas não há nenhum problema de gás malcheiroso, portanto, não é isso. O resultado? O Raspberry Pi tem algumas falhas graves, mas aqueles que podem ser superados para permitir que ele assista sobre sua casa. E já que este é um livro sobre o Pi, que é o que vamos usar. Usando uma rede de sensores O sistema de segurança em casa (e do centro de tempo em outro capítulo) é baseado no conceito de uma rede de sensores. Se um computador é como um cérebro, os sensores são como os sentidos que lhe permitem recolher informações junto e interagir com o mundo físico. Câmeras são como olhos, interruptores reed são como pontas dos dedos, e interruptores de pressão são como os dedos que têm foi pisado por um cão desajeitado. Os robôs não seria nada sem os seus sensores, e qualquer robô cérebro, por exemplo, é inteiramente dependente do que a rede de sensores. Isso, como uma questão de fato, é uma das coisas mais legais sobre o Pi sua capacidade de interagir facilmente com as coisas físicas como sensores. A maioria dos desktops e laptops modernos tiveram todas as suas portas interessantes, tais como a paralela e serial embora tomadas portas, à esquerda com nada, mas algumas portas USB solitárias e uma porta Ethernet. Isto os deixa aleijado, incapaz para interagir facilmente com o mundo "real". Enquanto isso, o Pi pode ser conectado diretamente a um sensor de movimento através de seus pinos GPIO e que você saiba, com algumas linhas de código, se Slenderman está rastejando sobre nos arbustos atrás de seu quarto. No nosso sistema de segurança, nós vamos usar vários sensores: um sensor de movimento infravermelho, um interruptor de pressão, um sensor magnético, e uma cana, ou interruptor de limite. O sensor de movimento pode ser colocado em qualquer lugar na propriedade. A pressão interruptor pode ser útil colocado dentro de uma porta, onde um intruso é provável para a etapa. O sensor magnético pode ser utilizada para detectar se uma janela é aberta, e o interruptor de lâmina pode ser usado para determinar se alguém toca um fio de viagem. Nós podemos usar a câmera onboard do Pi para tirar fotos se quaisquer sensores são tropeçou e acessar essas fotos a qualquer momento. Última, nós podemos usar nossa rede de casa para ter o Pi enviar uma mensagem de texto e / ou mensagem de e-mail deve ser algo interessante acontecendo em nossa segurança de rede-tipo de como a empresa de segurança chamando você se detectar um alarme. Esta é a rede de sensores que estará trabalhando com. É uma espécie de base, mas também é infinitamente expansível. E embora vamos estar usando um de cada tipo de sensor, você pode facilmente adicionar mais se você quiser (um sensor magnético para cada janela em sua casa, por exemplo). Compreendendo uma Pulldown Resistor Um conceito importante saber e lembrar sempre que usar uma entrada com quase qualquer circuito é a do flutuante de entrada e o resistor suspenso (ou pullup). Basicamente, quando um pino (tal como um pino GPIO na Pi) é configurado para ler a entrada de uma fonte de tensão, tal como um sensor, é o que se chama uma entrada flutuante até que alguma tensão é lido no pino. Antes que um sinal de tensão é enviada a partir do sensor, o nível no pino poderia ser quase nada. Esta não especificada, flutuante tensão pode estragar a sério com o seu programa: se você já programou a seqüência de autodestruição para ativar quando o pino lê um valor 2.3V, e o valor flutuante acontece para estar em 2.3V, BOOM! Precisamos de uma maneira de definir o pino para um valor conhecido (tais como uma elevada lógica ou um LOW lógica) quando nada está sendo lido a partir dele.
Capítulo 8 ■ O Sistema de Home Security A maneira de resolver este problema é usar um pullup ou pulldown resistor. Este resistor conecta o pino de entrada para quer Vcc ou GND (pullup ou pulldown, respectivamente). Dessa forma, se não houver entrada de entrar, o pino vai ler qualquer Vcc ou 0, e sabemos que valor. Isto é feito frequentemente com uma resistência física (10k ou 100KΩ, normalmente), mas muitos placas de desenvolvimento (incluindo o Pi) vai deixar você fazê-lo através de software de uma enorme vantagem quando você está trabalhando com espaço limitado. Usando a biblioteca GPIO, você pode declarar um pino como entrada e, ao mesmo tempo, "puxar para baixo" como se com um resistor suspenso com a seguinte sintaxe: GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) Isso define o valor lido no pino # 11 um preço tão baixo até que ele recebe tensão do sensor; nesse ponto, que é de tensão puxou ALTO, e o programa pode agir. Quando o valor ALTA desaparece, o pino é novamente puxado para baixo até que o processo de repete. Um resistor pullup faz quase a mesma coisa, exceto o pino é puxado HIGH (Vcc), até que uma entrada é exibida. A Lista de Compras de Peças A fim de construir um sistema de segurança funcionando, existem algumas peças que você vai precisar de: • A Raspberry Pi (obviamente) e adaptador de energia • A dongle USB sem fio se você quer ir sem fio com o Pi • módulo de câmera Raspberry Pi • Interruptor de pressão (como http://bit.ly/Owc8aN, por exemplo) • Sensor magnético (como http://bit.ly/1cis71c, por exemplo) • sensor de movimento (tais como http://bit.ly/1c35pQp, por exemplo) • interruptor Reed (como http://bit.ly/1k6n2RM, por exemplo) • Grande carretel de cabo Ethernet (frisado não termina é necessário comprar a granel para economizar dinheiro) • solda, ferro de solda, e jumpers variado fios e conectores Algumas destas peças são opcionais, é claro; tudo depende de quão profundo você quer que seu sistema de segurança para ser. Você pode até mesmo adicionar itens à sua lista como seu sistema de segurança cresce. Cada sensor apenas adiciona a sua rede de sensores, expandir o alcance do seu sistema. Conectando-se a rede sem fio Quando você configurar sua Pi como o principal controlador do seu sistema de segurança, terá de se conectar com a sua casa de rede, a fim de permitir que você acessar remotamente e administrá-lo e enviar-lhe uma mensagem de texto para o informar sobre uma infração. Quando você se conectar à sua rede, você tem a opção de ir com ou sem fio. Cada opção tem a sua prós e contras, é claro, mas eu sugiro que você usar uma conexão sem fio. Isto é principalmente por duas razões: uma sem fio conexão permite que você coloque o Pi em qualquer lugar sem ter que executar o cabo Ethernet à sua localização, e um sem fio conexão também é mais segura com ele, um assaltante pode cortar uma conexão física com o Pi para torná-lo inútil, mas não é assim com uma conexão sem fio. A primeira coisa que você precisa é um bom dongle USB sem fio. Um popular é a Edimax EW-7811UN (mostrado na Figura 8-1), disponível na Amazon por apenas alguns dólares. Ele funciona bem, é fácil de configurar e não requer um hub USB para operar bem no Pi.
Capítulo 8 ■ O Sistema de Home Security Figura 8-1. O adaptador sem fio Edimax Em seguida, você vai querer configurar o Pi ter um endereço IP estático. Isto irá permitir que você efetue login na sua Pi remotamente a partir de em qualquer lugar, independentemente de ele ter sido desligado desde o seu último login remoto. Se você deixar o Pi para receber o seu Endereço IP dinamicamente a partir de seu roteador doméstico, é possível que o endereço IP será alterado se o Pi tem para reiniciar, significado você vai ser capaz de log in (porque você não vai saber o que o novo endereço é). Felizmente, a criação de um IP estático para a conexão sem fio do seu Pi não é difícil. Você precisa conhecer a sua rede de máscara de rede (normalmente, seja 255.255.255.0 ou 255.255.0.0) e seu endereço de gateway (normalmente, o endereço do seu roteador,
tais como 192.168.2.1). Você também vai precisar do seu valor Bcast, onde pode encontrar digitando ifconfig na linha de comando. Abra seu arquivo / etc / network / interfaces para edição digitando sudo nano / etc / network / interfaces Você vai ter que usar o sudo, porque o arquivo é editável apenas pelo usuário root. Você deverá ver uma linha que lê iface wlan0 inet dhcp Mudar isso para ler iface wlan0 inet static e adicione o seguinte abaixo: endereço 192.168.2.50 (ou qualquer outro endereço que você quer, obviamente) 255.255.255.0 máscara de rede (ou sua máscara de rede) 192.168.2.0 rede (local da sua rede) transmitido 192.168.2.255 (o seu valor Bcast de mais cedo) gateway de 192.168.2.1 (o endereço IP do seu roteador) Salve o arquivo e reinicie o Pi. Quando se trata de volta on-line, ele deve ter o endereço que você check-double-especificado executando um comando ifconfig. Agora você tem um endereço IP estático. Anotá-la para que você não esqueça. Agora não importa onde você acaba colocando o Pi em sua rede de segurança, você vai ser capaz de ligar-se remotamente para administrá-lo. Para usar o IP estático, você precisará de um servidor SSH em execução no Pi. Dependendo de como você configurar seu Pi, você pode ter uma corrida já. A maneira mais fácil de obter o seu servidor SSH instalado e funcionando é executar o seu Raspi-config ferramenta digitando sudo Raspi-config na linha de comando. Você será saudado com a tela do Raspi-config (como mostrado na Figura 8-2).
Capítulo 8 ■ O Sistema de Home Security Figura 8-2. A ferramenta Raspi-config
Cursor para baixo para a opção # 8, Opções avançadas, pressione a tecla seta para a direita para destacar
Capítulo 8 ■ O Sistema de Home Security Em seguida, de volta para fora da ferramenta Raspi-config selecionando
Capítulo 8 ■ O Sistema de Home Security Figura 8-4. O diagrama de pinagem de pinos GPIO do Pi ■ Nota Tenha em mente que com GPIO.setmode (BOARD), quando você se refere a pino 11, na verdade você está se referindo à física pino # 11 (que se traduz em GPIO17 no diagrama na Figura 8-4), não GPIO11, que se traduz para o pino físico # 23. Depois de definir o modo, você pode então definir cada pino para ser uma entrada ou uma saída. Os usuários do Arduino vai provavelmente reconhecem o conceito aqui: GPIO.setup (11, GPIO.OUT) GPIO.setup (13, GPIO.IN) e assim por diante. Depois de definir um pino como uma saída, você pode então enviar tensão para ele (ligá-lo) usando GPIO.output (11, 1)
Capítulo 8 ■ O Sistema de Home Security ou GPIO.output (11, True) e, posteriormente, desligá-lo usando GPIO.output (11, 0) ou GPIO.output (11, False) Quando você configurar um pino como uma entrada, lembre-se de definir um pullup ou pulldown resistor como discutido anteriormente. Configurar o sensor de movimento Uma das partes mais importantes de uma rede de segurança em casa é provável que o sensor de movimento (mostrado na Figura 8-5) -com uma algumas ressalvas. Você não pode confiar exclusivamente em seu sensor de movimento, porque no momento em que fizer, ele vai ser compensado por um bairro gato, ou possivelmente um Yeti (não necessariamente uma coisa ruim.) Se, no entanto, você usá-lo, além de todos os outros sensores, você pode ter boa sorte com seus resultados. Figura 8-5. O sensor de movimentos O sensor que estamos usando, por Parallax ou um clone próximo, detecta movimento por mudanças na detecção infravermelha (calor) níveis emitidos por objetos no ambiente circundante. Como a maioria dos sensores, que, em seguida, sinaliza que a mudança tem sido detectados por emitir um sinal ou "HIGH" "1" no seu pino de saída. Ele tem três pinos: Vcc, Gnd, e Output. Os pinos são (da esquerda na Figura 8-5) OUT, + e -. Um recurso interessante deste sensor em particular é que ele pode usar qualquer tensão de 3V a 6V. Para usar e testá-lo, conecte o (-) pino para pino terra do Pi (pino # 6), conecte o pino (+) para pino 5V do Pi (pino # 2), e conectar o pino OUT a um dos pinos GPIO. Para testar o sensor e nossa força de codificação, vamos começar por definir os pinos GPIO em conformidade. Podemos usar um configuração simples para testar o nosso código-um LED em uma placa de ensaio que se acende quando o sensor é acionado. Começar de novo Script Python (vamos chamá-lo motion.py) com nano motion.py e digite o seguinte: importação RPi.GPIO como GPIO tempo de importação GPIO.setwarnings (False) #eliminates lancinante da biblioteca GPIO.setmode (GPIO.BOARD)
Capítulo 8 ■ O Sistema de Home Security GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup (13, GPIO.OUT) while True: Se GPIO.input (11): GPIO.output (13, 1)
outro: GPIO.output (13, 0) Isso é tudo para o código de teste! A fim de testá-lo, primeiro conectar o pino (+) sobre o sensor ao pino # 2 sobre o Pi. Conectar o pino OUT ao pino # 11 sobre o Pi. Conecte o - pin a uma linha de base comum sobre a sua placa de ensaio (). Finalmente, conecte pino nº 13 do Pi para a perna positiva de sua LED (através de um resistor), e conecte a perna negativo do LED para o linha de base comum. Você deve acabar com algo como você vê na figura 8-6. Figura 8-6. Testando o sensor de movimento Quando você executar o script anterior (lembrando-se de usar o sudo porque você está acessando os pinos GPIO), o LED deve acender quando você mover sua mão ao redor do sensor, e em seguida, ele deve ir para fora outra vez depois de alguns segundos de não movimento. Se isso não funcionar, verifique as conexões e sua peças de um LED queimada pode causar todos os tipos de dores de cabeça de solução de problemas, acreditem! Deixar o sensor conectado como ela é, como vamos usá-lo em nosso sistema, e vamos passar para o interruptor de lâmina.
Capítulo 8 ■ O Sistema de Home Security Configurando o Interruptor de Lâmina A cana, ou limite, interruptor é uma ferramenta útil em muitas situações, não menos do que sendo o nosso sistema de segurança. É do frequentemente utilizado por robôs para determinar os limites do movimento, se está dirigindo em uma parede ou fechar uma pinça em torno de um objeto. Seu conceito é simples: o interruptor é normalmente aberto, deixando nenhuma tensão por meio, e tem uma armadura saliente do corpo do detector, como uma alavanca comprida. Quando um objeto exterior pressiona a alavanca, ele fecha o alternar, o envio de tensão através do circuito, no nosso caso, para o pino de INPUT do Pi que está a ouvir um sinal. o interruptor de limite que estamos usando é também chamado de "interruptor de ação rápida sub-miniatura." (Ver Figura 8-7.) Figura 8-7. O interruptor de limite O longo braço saliente do corpo do interruptor permite que objetos que estão longe para fechar o comutador contactea à pequena protuberância saliente do switch. Ele tem três terminais, mas estamos indo só para usar dois, por que estamos interessados somente em quando o interruptor fecha. No nosso caso, vamos usar um interruptor de limite não para determinar quando um objeto se aproxima demais, mas para determinar se um fio de viagem tem sido puxado. Você pode montar o interruptor na parede e executar um fio fino ou linha de pesca da parede oposta a alavanca do interruptor. Posicioná-lo de modo que se alguém entra na lista de discussão, eles vão puxar a alavanca para baixo, ativando o interruptor. Porque nós estamos usando um interruptor físico aqui, em vez de um sensor como o detector de movimento, é importante que eu apresentá-lo ao conceito de debouncing. Um aspecto comum de switches físicos é que porque eles são muitas vezes feitas de metais primavera, quando eles são ativado pela primeira vez que eles tendem a saltar para além de um ou mais vezes antes de fazer uma constante contato. O resultado é uma muito rápido de ligar-desligar-ligado-desligado-ligado-desligado "Chatter" antes que a tensão se instala a uma alta ou baixa constante. Para combater isso, nós Debounce o interruptor por ler a partir dele somente quando ele não é mais indo e voltando, assim: tempo de importação prev_input = 0 while True: #take uma leitura entrada = GPIO.input (11) #if a última leitura foi baixa e esta alta, impressão if ((não prev_input) e entrada): print ("botão pressionado") #update entrada anterior prev_input = input #slight pausa para Debounce time.sleep (0,05)
Capítulo 8 ■ O Sistema de Home Security Este pequeno script ilustra o conceito muito bem. Ele ignora pressionar um botão, se ocorrer a menos de 0,05 segundos após a última. Então, para testar a nossa chave, vamos ligá-lo a alguns pinos GPIO e certificar-se de que podemos ler a entrada quando seu estado alterar. Basta usar o interruptor, ligue o pino de alimentação do Pi (# 2) para pino mais à esquerda do interruptor conforme mostrado na Figura 8-7. Em seguida, conecte o meio pin à sua de Pi pin # 11. Tente o seguinte código digitando tempo de importação importação RPi.GPIO como GPIO GPIO.setwarnings (False) GPIO.setmode (GPIO.BOARD) GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) prev_input = 0 while True: entrada = GPIO.input (11) if ((não prev_input) e entrada): print "botão pressionado" prev_input = input time.sleep (0,05) Quando você executar este script (lembrando-se de usar o sudo), pressionando o interruptor irá enviar tensão diretamente através dele do pino a pino # 2 # 11, registrando assim tão alto no pino # 11. É um sinal debounced, ea Pi deve imprimir "Botão pressionado "quando você pressiona o botão. Parabéns! Você é capaz de ler quando uma tecla é pressionada! Vamos passar para o próximo switch. Configuração do interruptor de pressão O interruptor de pressão é muito semelhante ao interruptor limite, que parece muito diferente. (Ver Figura 8-8.) Figura 8-8. O pressostato Em vez de uma alavanca física e botão, uma almofada quadrada que é usado simplesmente registra pressão como uma mudança na tensão. Por esta razão, é ainda mais fácil de ligar o interruptor de limite. Conecte seu pino do Pi # 2 com uma das ligações, e conecte a outra vantagem para o pino # 11. Em seguida, executar o mesmo script como você fez para o fim de curso, e testá-lo, pressionando para baixo no teclado com o dedo. Voilá! Você está lendo agora um valor de uma chave de pressão! Isto é perfeito para a leitura uma passo debaixo de um tapete de boas-vindas, por exemplo.
Capítulo 8 ■ O Sistema de Home Security Ligar o Sensor Magnético O sensor magnético (mostrado na Figura 8-9) é um pequeno dispositivo que, enquanto não utilizada do lado de fora de certos específica aplicações, pode vir a calhar para aplicações como o nosso. Ele mede o campo magnético circundante e envia um sinalizar quando que as mudanças de campo. Por essa razão, é muito bom em determinar quando a posição relativa de duas peças de metais foram alterados, por exemplo. Figura 8-9. O sensor magnético A fim de se certificar de que não obter quaisquer leituras falsas, podemos usar alguns pequenos ímãs externos para influenciar o sensor; o que estamos usando vem com dois pequenos ímãs de neodímio para esse fim. Para testar o nosso sensor magnético, podemos novamente usar o nosso código switch.py temos vindo a utilizar. Ligue os fios de ligação que veio com o sensor ao bloco conector do sensor, e, em seguida, conectá-los ao seu Pi: vermelho para o pino # 2, preto ao pino # 6, e branco ao pino # 11. Agora é só alterar o código para ler tempo de importação
importação RPi.GPIO como GPIO GPIO.setwarnings (False) GPIO.setmode (GPIO.BOARD) GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) prev_input = 0 while True: entrada = GPIO.input (11) if ((não prev_input) e entrada): print "O campo mudou" prev_input = input time.sleep (0,05) e executar o script. Seu terminal permanecerá em branco até que você acena o ímã passado o sensor. (Você pode ter que experimentar com diferentes distâncias e velocidades. Minha experiência é que os ímãs têm de passar bem de perto a registre-se.) Nesse ponto, ele vai dizer "campo mudou." Depois de um pouco de experimentação, você saberá exatamente onde você terá para montar o ímã para que a mudança nas leituras de campo para influenciar seu sistema de segurança. Agora você pode montar o sensor de um painel de uma janela deslizante, por exemplo, um ímã e por outro painel, e se a janela slide aberto, o sensor magnético irá registrar o movimento do ímã.
Capítulo 8 ■ O Sistema de Home Security Configurando Câmara de Pi Por fim, uma das características que torna o Pi atraente como eixo central do sistema de segurança é a sua capacidade de tirar fotos de um pequeno, câmera embutida. Enquanto isso significa que o Pi deve ser posicionado em uma localização estratégica, a fim de pegar nada de interessante, o Pi é tão pequena que encontrar um bom lugar para ele não deve ser um problema. A fim de tirar fotos, você terá que ter dois componentes que trabalham em seu Pi: o acesso sem fio e câmera. Discuti a instalação sem fio mais cedo; a câmera pode ser configurada com a ferramenta Raspi-config, se você não tem configurou-o já. Depois de ativar a câmera, você tem dois comandos que você pode usar: raspistill (para capturar imagens) e raspivid (para captura de vídeo). Cada um pode ser usado com vários flags e opções para alterar o tamanho do quadro, a taxa de capturar, e outras configurações. Nós estamos interessados em tirar fotos estáticas, no entanto; streaming de vídeo através do feed ao vivo, enquanto possível, requer alguns ferramentas de software extra que pode ser difícil de configurar. Tirar uma foto é uma simples chamada para raspistill do comando linha. E enquanto não há nenhuma biblioteca ou módulo Python disponível como esta escrito a usar a câmera, podemos usar o chamada de biblioteca de subprocess chamada de importação para fazer a mesma coisa. Quando você precisa para tirar uma foto no seu script, usar essas duas linhas simples: de subprocess chamada de importação ligar para (["raspistill -o image.jpg"], shell = True) A imagem ainda, identificado como "image.jpg", será armazenado no diretório atual. Podemos colocar esta linha de tirar fotos em um take_pic () função e chamá-lo sempre que um sensor é acionado. Temos, então, a evidência, devemos precisar dele para corroboração! Enviando uma mensagem de texto a partir do Pi Na minha opinião, ter seu Pi enviar-lhe uma mensagem de texto quando algo incomum acontece é uma das melhores partes o projeto, e é particularmente útil se você estiver indo para fora da cidade. Uma notificação do seu Pi pode deixá-lo saber que você precisa chamar o seu vizinho (ou a polícia) e tê-los verificar em sua casa. É realmente muito simples: o Pi usa o rede local para enviar uma mensagem de e-mail, que é então traduzido por sua operadora de celular em uma SMS, ou mensagem de texto. Você vai precisar de uma conta de e-mail que é acessível via web; a maioria de nós tem uma conta do Gmail ou Yahoo, por exemplo. Você vai
também precisa saber como enviar um texto via e-mail com sua operadora de celular. Cada t ransportador é ligeiramente diferente, mas a base conceito é o mesmo, enviando um email para um determinado número (
Capítulo 8 ■ O Sistema de Home Security Chamar a função send_text () com uma string como "OMG eu estou sendo roubado!" Irá enviar-lhe uma mensagem de texto. Obviamente, esse código é projetado para trabalhar com a AT & T, e usa uma conta do Gmail. Você vai precisar de modificá-lo como necessário para seu provedor de suporte e-mail. acesso SMTP do Gmail é através da porta 587, como você pode ver na linha 9 no código anterior; esta pode ser diferente para o Yahoo ou MSN. Você pode chamar esta função quando detectar uma entrada em qualquer um dos seus sensores, e você pode até mesmo ajustar a seqüência de caracteres enviados de acordo com a qual sensor está desarmado. Implementando o Callback Há uma idéia significativa à esquerda para explorar neste projeto, e que é o conceito de retorno de chamada. Você pode ter reparou que não há nenhuma maneira fácil de verificar cada chave; você tem que continuar a "poll" cada chave e esperar que nada incomum acontece enquanto você está fazendo outra coisa. Não é um grande negócio se você tem apenas três ou quatro interruptores e sensores, mas você deve começar a adicionar à sua rede, o atraso entre algo acontecendo e ser notificado sobre ele pode ficar difícil de manejar rapidamente; interruptor de limite # 2 poderia tropeçar enquanto você está verificando sensor magnético nº 16, e você não vai saber sobre isso por mais dois segundos. Por esse tempo, é claro, o ladrão pode ter escapado pelo fio de viagem e estar bem no seu caminho para matar toda a sua família ou o roubo de Star Wars recordações. Felizmente, Python (e do Raspberry Pi) tem uma resposta para esse problema de verificação de switch. É incorporado no RPi.GPIO biblioteca: a. Callback interrupção rosca O que isso nos permite fazer é iniciar uma discussão programa diferente para cada switch. Cada segmento vai entrar em um modo de "espera", sem fazer nada, enquanto o resto do programa (e o resto dos fios) ir sobre seus negócios. Se e quando o interruptor fica desarmado, ele imediatamente emite uma chamada de retorno, ou interromper, ao programa principal para deixá-lo saber ("Hey! Eu tenho tropeçou aqui!") e execute qualquer função que quer que seja. Desta forma, podemos ter certeza de que não vai perder um importante pressione o botão ou interruptor de viagem. Enquanto isso, todo o outros tópicos continuar seu padrão de exploração. Na parte inferior deste padrão, as funções de um interruptor como uma base ; Se aquele interruptor é acionado, você pode terminar o programa. Caso contrário, ele continua dentro de um loop while. Esta funcionalidade de chamada de retorno é realizado utilizando qualquer uma das duas funções: GPIO.wait_for_edge () ou GPIO.add_event_detect (). GPIO.wait_for_edge () faz exatamente isso, espera por uma borda subindo ou caindo em qualquer pin especial e, em seguida, atua quando detecta que borda. GPIO.add_event_detect (), por outro lado, para uma espera subindo ou caindo borda em um pino em particular e, em seguida, chama a função declarada em seus parâmetros. Você pode vêlos tanto em uso no código final mais tarde neste cCapítulo. Esteja ciente de que para cada sensor ou interruptor, temos um exclusivo callback função de um que é exclusivo para esse sensor para que possamos saber exatamente quais interruptor foi acionado. Conectando todos os bits Agora que você determinou como usar todas as peças desse quebra-cabeça, vamos rapidamente sobre como conectar tudo. Você vai precisar usar o cabo Ethernet para fazer todas as suas conexões; é forte, fácil de trabalhar com, e (principalmente) à prova d'água. Tira o invólucro exterior para alcançar os fios dentro, e pique todos, mas os dois ou três fios que você precisa conectar cada sensor para sua Pi. Você vai precisar de uma pequena placa de ensaio para colocar ao lado do Pi, porque tudo deve
compartilhar um terreno. Encontre um bom lugar para montar sua Pi, onde você pode ligá-lo (sem se preocupar com baterias) e onde você pode montar a câmera para que ele possa tirar boas fotos da ação. Depois de encontrar um lugar, você pode usar putty cartaz para manter tudo no lugar. Finalmente, encontrar bons lugares para todos os seus sensores. Lembre-se, eles não precisam estar em vista o Pi: enquanto você pode executar o cabo Ethernet para eles, é um bom local. Conecte os cabos de forma segura e de tal forma que ninguém tropeça eles. Ligue todos os fios negativos para a sua fila terreno comum em sua placa de ensaio, e conectar cada positivo fio para um pino GPIO. Nesta fase, provavelmente seria uma boa idéia para escrever o que sensor é ligado ao pino de modo que que você pode fazer referência a ela em seu código.
Capítulo 8 ■ O Sistema de Home Security O código final Assim que completa todas as partes individuais deste projeto. Tudo o que resta é colocá-los todos juntos em seu código final, assim (você pode baixar o arquivo de código final, chamado home_security.py em apress.com): tempo de importação importação RPi.GPIO como GPIO de subprocess chamada de importação import string smtplib importação GPIO.setwarnings (False) GPIO.setmode (GPIO.BOARD) time_stamp = time.time () #For debouncing pins #set #pin 11 = sensor de movimento GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) #pin 13 = sensor magnético GPIO.setup (13, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) #pin 15 = fim de curso GPIO.setup (15, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) #pin 19 = pressostato GPIO.setup (19, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) take_pic def (sensor): ligue para (["raspistill -o imagem" + Sensor + ".jpg"], shell = True) time.sleep (0,5) #WAIT 1/2 segundo para pic a serem tomadas antes de continuar send_text def (detalhes): HOST = "smtp.gmail.com" ASSUNTO = "Break-in!" AO = "xxxxxxxxxx@txt.att.net" DE = "python@mydomain.com" text = detalhes BODY = string.join (("From:% s"% FROM, "Para:% s"% TO, "Assunto:% s"% ASSUNTO, "", texto), "\ r \ n") s = smtplib.SMTP ("smtp.gmail.com", 587) s.set_debuglevel (1) s.ehlo () s.starttls () s.login ("username@gmail.com", "minhasenha") s.sendmail (DE, [TO], CORPO) s.quit () motion_callback def (canal): time_stamp mundial time_now = time.time () Capítulo 8 ■ O Sistema de Home Security
if (time_now - time_stamp)> = 0,3: #check para debouncing print "detector de movimento detectado." send_text ("detector de movimento") take_pic ("movimento") time_stamp = time_now limit_callback def (canal): time_stamp mundial time_now = time.time () if (time_now - time_stamp)> = 0,3: #check para debouncing print "Fim de curso pressionado." send_text ("switch Limite") take_pic ("Limite") time_stamp = time_now magnet_callback def (canal): time_stamp mundial time_now = time.time () if (time_now - time_stamp)> = 0,3: #check para debouncing print "Sensor magnético disparou." send_text ("Sensor magnético") take_pic ("ímã") time_stamp = time_now #Corpo Principal raw_input ("Pressione Enter para iniciar o programa \ n") GPIO.add_event_detect (11, GPIO.RISING, callback = motion_callback) GPIO.add_event_detect (13, GPIO.RISING, callback = magnet_callback) GPIO.add_event_detect (15, GPIO.RISING, callback = limit_callback) Interruptor # pressão termina o programa # Você pode facilmente adicionar um retorno de chamada única para o interruptor de pressão # E adicionar outro interruptor apenas para desligar a rede experimentar: print "Esperando por sensores ..." GPIO.wait_for_edge (19, GPIO.RISING) exceto KeyboardInterrupt: GPIO.cleanup () GPIO.cleanup ()
Resumo Neste cCapítulo, você aprendeu sobre o que são os sensores, o conceito de uma rede de sensores, e como ligar diferentes sensores para pinos GPIO do seu pi. Você configura o interruptor de limite, interruptor de pressão, sensor magnético, e sensor de movimento (que também usar no brinquedo gato Pi-alimentado no próximo cCapítulo). Com o conhecimento que você ganhou aqui, você agora têm a capacidade de criar um sistema de segurança de tamanho completo, com a sua amplitude limitada apenas pela quantidade de sensores tiver e quanto fio você tem que colocá-los todos juntos.
Capítulo 9 O Toy Cat A maioria das pessoas são bastante familiarizado com o "gato que persegue o pequeno ponto vermelho" paradigma. É tão popular que até tinha um curto cena numa das Shrek filmes. Alguns gatos perseguir o ponto de laser até cair. Alguns só vai persegui-lo por um pouco
enquanto. Em qualquer caso, qualquer pessoa que tenha um gato provavelmente já tocou com um ponteiro laser com o seu amigo felino em algum ponto. Mas não seria bom se você pudesse entreter seu gato quando você não está lá? Um ponteiro laser, ao contrário do que você poderia pensar, se não tem que ser mantido e controlado por um humano. Um pouco de programação e engenharia mecânica magia, e você tem-se um brinquedo de gato autônoma. No entanto, no projeto gato-brinquedo vamos construir neste cCapítulo, não vamos deixar por isso mesmo. Nós apenasnão pode. Afinal, não seria faz sentido ter o brinquedo sempre em movimento, com ou sem o seu gato está por perto para brincar com ele, não é? Então, vamos adicionar algo um especial sensor infravermelho. Dessa forma, ele vai ligar apenas quando seu gato está por perto, e ele vai desligar quando o gato deixa a sala. Você está pronto? Vamos começar por obter as peças que você precisa para criar o nosso brinquedo de gato. A Lista de Compras de Peças Um recurso interessante do brinquedo do gato, além de ser simples e caseiro, é que as peças são realmente muito barato. Você vai precisar do seguinte: • A Raspberry Pi. • Dois padrão (não contínua) servos-I recomendar o Parallax 900-00005 (Http://www.parallax.com/product/900-00005), mas qualquer modelo vai funcionar. • Um ponteiro laser barato, que você pode comprar em uma loja de animais para cerca de US $ 10 US. (Ver Figura 9-1.)
Capítulo 9 ■ O Toy Cat Figura 9-1. Um ponteiro de laser comum usado com o brinquedo do gato • Um sensor de movimento PIR (http://parallax.com/product/910-28027). • Glue / epóxi. • fios Diversos (vermelho, preto, e assim por diante). • parafuso de cabeça plana. • Fita isolante. • picolé stick. • Bateria de 9V. • Um recipiente em que para montar tudo, eu usei um pequeno pedaço de tubo de PVC. O conceito por trás da Toy A chave para fazer este trabalho brinquedo é movimento aleatório. Se programar o brinquedo para fazer uma série de círculos concêntricos, um após outro, e depois repetir o padrão, não vai demorar muito para o seu gato para reconhecer o padrão e se cansar. Contudo, usando do Python aleatórios ou randint funções, você pode embaralhar os padrões e manter o seu gato (e, possivelmente, o seu criança) entretidos. Outro aspecto a ter em mente é que você vai ser a randomização o movimento em dois eixos-eixo-x e o eixo dos y, mantendo-a dentro de certos limites de movimento (que é o local onde os parâmetros das funções randomizing e os extremos de movimento dos servos entrar). Você estará usando dois servos, mas eles vão ser unidas de forma para controlar o movimento de um ponteiro laser. Para controlar os servos, como vários outros projetos neste livro, nós usaremos o Pinos GPIO do Pi e biblioteca GPIO do Python. Outra coisa agradável sobre este projeto é que os servos acabam desenhando assim pouca energia que pode ser obtida com uma bateria de 9V simples. Você ainda precisa para poder deles separadamente do Pi (Sempre uma boa idéia, independentemente do projeto), mas você não precisa de uma configuração de fantasia da bateria como você faz com muitos outros projetos.
Capítulo 9 ■ O Toy Cat Criando e usando números aleatórios Você pensaria criação e utilização de números aleatórios seria simples. Basta chamar uma função, obter um número inteiro aleatório, e prossiga. Embora isso possa ser como ele funciona na prática e é tudo o que a maioria de nós pensar, o processo real de saída de randomização é fascinante-é realmente o assunto de intenso estudo por muitos cientistas da computação e matemáticos. (Veja o quadro "Oh, a aleatoriedade".) Para obter um número aleatório em Python, você pode usar vários built-in funções. O primeiro é, apropriadamente, a função random (). A função aleatório retorna um float (a ponto flutuante, número decimal). Ele não usa nenhum parâmetro, retornando ao invés de um número aleatório entre 0,0 e 1.0. Isso é muitas vezes muito útil, mas para os nossos propósitos, vamos precisar números, de preferência um pouco maiores, em um formato inteiro, que pode ser feito com a função randint ().
OH, a aleatoriedade Desde os tempos antigos, os humanos tiveram muitos métodos para gerar números "aleatórios", de lançar uma moeda, para rolar um dado, para baralhar um baralho de cartas. E para a maioria das aplicações, qualquer um destes seria bom para gerar uma número aleatório ou conjunto de números. Se você precisa decidir que chuta a bola em primeiro lugar, você pode lançar uma moeda; escolher um cartão fora de um baralho de 52 é aleatório o suficiente para torná-lo muito impressionante quando um mágico adivinha com sucesso sua identidade. No entanto, existem duas questões principais com o uso destes métodos para gerar números aleatórios para qualquer verdadeira esforço matemática ou estatística. Primeiro de tudo, eles são todos baseados em sistemas físicos, a tampa de uma rodada moeda no ar, o rolamento de um dado mais ou menos quadrado em um patch não-tão-nível de chão. Porque eles são física sistemas, eles nunca podem ser verdadeiramente aleatória. Dada suficiente iterações, um padrão irá, eventualmente, começam a surgir baseada
em imperfeições no sistema. Uma moeda, por exemplo, tem um ligeiro desvio do peso de um lado, devido aos padrões gravado em ambas as faces. Se você lançá-lo bastante vezes, esse padrão irá mostrar-se nos resultados coletados. Pode demorar vários milhões ou vários bilhões de flips, mas vai emergir. Do mesmo modo, um molde nunca será perfeitamente quadrada ou perfeitamente ponderadas, e, eventualmente, mostram uma tendência para um lado, depois de uma quantidade suficiente de rolos. O segundo problema com esses métodos de geração de números aleatórios é simplesmente que eles tomam muito tempo. Se você precisa de um bom lote de um milhão de números aleatórios, você vai ser lançando uma moeda para um longo tempo para obter todas esses números. É apenas impraticável para grandes lotes de dados. Mas os computadores são excelentes em lidar com lotes imensos de números e dados, e eles podem gerá-los incrivelmente rápido. O computador de mesa médio pode processar a uma velocidade teórica de cerca de 7 Gigaflops. (Isso é 7 bilhões de operações de ponto flutuante por segundo.) A essa velocidade, gerando um milhão de números aleatórios levaria ... bem, vamos ver ... transportar os dois ... dividir por amarelas ... um ... cerca de 7 milissegundos. Muito mais rápido que o cartão de embaralhar. No entanto, os computadores, mais uma vez, são sistemas físicos. Sim, você está gerando os números de dentro do "Ciberespaço" do processador central do computador, mas que o processador é um chip de silício física, com física transistores e fios. Não importa o programa que você usa para gerar esses números aleatórios, eles acabarão por exibir um padrão que mostra que eles não são verdadeiramente aleatórios. Assim, você vê o interesse em números aleatórios por matemáticos e cientistas. Um gerador de números verdadeiramente aleatórios seria extremamente útil em muitas áreas da ciência, não menos do que é a criptografia. A maioria das cifras são baseadas em um código de hash aleatório; um verdadeiramente aleatório código seria infinitamente mais difícil de decifrar-que é uma das razões para o interesse intenso. Geradores de números aleatórios atuais funcionam utilizando algoritmos que criam longas seqüências de números pseudo-aleatórios, frequentemente com base em combinações de multiplicações e as operações de módulo. Dependendo da qualidade do algoritmo, os números assim gerado pode ou não ser criptograficamente som, apesar de serem na maioria das vezes aleatório
o suficiente para aplicações como jogos de vídeo. Em outras palavras, o algoritmo utilizado para gerar números aleatórios provavelmente não vai parar um esforço concertado para quebrar o código de um supercomputador, mas é bom o suficiente para gerar oponentes quando você joga Call of Duty: The Day We All morreu nas mãos da Sexta-Grader para baixo do bloco. Capítulo 9 ■ O Toy Cat Este processo de geração é por isso que, quando você começa um programa que vai estar usando números aleatórios, você tem que "Seed" do gerador de números aleatórios com outro número, como a data de hoje ou a hora do sistema no seu computador. A semente aleatória é simplesmente um número usado para inicializar o algoritmo de vetor de número aleatório na programa. Assim, desde que a semente original é ignorada, inicializações subsequentes devem fornecer suficientemente aleatório números. Sim, eventualmente, um padrão vai emergir-é inevitável, mas um gerador aleatoriamente-semeado deve ser suficientemente aleatória para a maioria das necessidades, em particular um brinquedo gato aleatório-motion. O gato de Schrödinger pode não ser enganado, mas seu felino deve ser. (Desculpe-só um pouco humor da física lá.) De acordo com os documentos Python, randint (a, b) retorna um número aleatório N, de tal modo que n está entre a e b, inclusivo. Em outras palavras, o seguinte código >>> Import aleatória >>> X = random.randint (1, 10) >>> Print x deve retornar 1, 2, 3, 4, 5, 6, 7, 8, 9 ou 10. Nós vamos usá-lo para gerar posições para os servos que usamos. ■ ■ Nota Os docs Python podem ser encontradas em http://docs.python.org. Eu recomendo que, como você aprender a língua, você tem o hábito de consultar os docs. Você também pode digitar help (função) no Python interativo prompt para obter o mesmo material de leitura.
Utilizando a biblioteca GPIO Agora que você tem uma idéia de como vamos gerar os nossos números aleatórios, você precisa saber como controlar a servos que serão anexados ao Pi. Felizmente, há uma biblioteca Python que foi projetado especificamente para esta finalidade que vem pré-instalado no Pi. Esta biblioteca permite-nos aceder a saída General Purpose Input do Pi (GPIO) pins e é chamado, simplesmente, RPi.GPIO. Para trabalhar com a biblioteca, você pode ter que instalar manualmente duas outras bibliotecas. Primeiro verifique se o seu Pi está actualizado digitando sudo apt-get update e, em seguida, instalar os pacotes, digitando sudo apt-get install python-dev e sudo apt-get install python.rpi-GPIO Nós podemos começar a escrever o nosso código final para este projeto. Lembre-se, ele está disponível como cat-toy.py de Apress.com. Agora, para acessar o Pi, você chamar o seguinte nas primeiras linhas de seu programa: importação RPi.GPIO como GPIO
Capítulo 9 ■ O Toy Cat Em seguida, configure-lo digitando GPIO.setmode (GPIO.BOARD) que permite identificar os pinos de como eles são rotulados em um diagrama de pinagem padrão, mostrada na Figura 9-2. Figura 9-2. Pinout de pinos GPIO ■ Nota Tenha em mente que com GPIO.setmode (GPIO.BOARD), quando você se referir ao pino 11, na verdade você está se referindo ao pin física # 11 (que se traduz em GPIO17 no diagrama na Figura 9-2), não GPIO11, que traduz para o pin física # 23). Capítulo 9 ■ O Toy Cat Depois de definir o modo, você pode então definir cada pino para ser uma entrada ou uma saída. Os usuários do Arduino vai provavelmente reconhecem o conceito aqui, mas isso é o que você digita para o Pi: GPIO.setup (11, GPIO.OUT) GPIO.setup (13, GPIO.IN) e assim por diante. Depois de definir um pino como uma saída, você pode então enviar tensão para ele (ligá-lo), inserindo GPIO.output (11, 1) ou GPIO.output (11, True) Posteriormente, você pode desligá-lo, inserindo GPIO.output (11, 0) ou GPIO.output (11, False) Usaremos dois pinos para ser servo controles: um pino para ligar o ponteiro do laser, e outro para ler a entrada do Sensor IR.
Controlando o Servo Servos são uma parte importante de muitas, muitas aplicações diferentes, de veículos controlados por rádio para high-end robótica. Um servo é, na sua essência, nada mais do que um motor DC. No entanto, com a ajuda de software você pode ter extremamente bom controle sobre a rotação do motor. Por exemplo, se você precisar dele para rodar 27,5 graus e, em seguida, parar
(e assumindo que o servo é capaz), você pode enviá-lo de que o comando de programação. Então, como você faz isso usando os pinos GPIO sobre o Pi? Infelizmente, você não pode simplesmente ligar o fio de sinal do servo (o branco, geralmente) em um pino GPIO para fora, dar-lhe uma tensão positiva e negativa, e esperar que ele funcione. Pode, mas em seguida, novamente ele não pode. A resposta está em como controlar servos. Como peças analógicas de hardware, eles são anteriores a maior parte digital de hoje hardware, incluindo a Pi. Eles funcionam utilizando modulação de largura de pulso (PWM). Para controlá-los, você deve ser capaz de enviar sinais PWM via qualquer mecanismo que você está usando, se é um pino de Arduino, cabo serial, ou Pino GPIO do Raspberry Pi. Se você deseja definir a posição de um servo, você precisa enviá-lo pulsos regulares de corrente-50 vezes por segundo é uma média de pulso de velocidade em vez de um pulso longo. Que 50 vezes por segundo traduz-se você estiver pensando-a um impulso a cada 20 milissegundos (ms). O comprimento do pulso, que, além disso, é o que determina a posição do servo. Um no pulso de 1,5 ms, para exemplo, enviou a cada 20 milissegundos, irá enviar o servo para a posição central. Pulsos mais curtos vai transformá-lo um direção, enquanto pulsos mais longos irá enviá-lo a outro. Assim, precisamente por o comprimento de temporização dos impulsos para o enviar servo, você pode posicionar precisamente a cabeça servo. O gráfico da Figura 9-3 ilustra isso melhor.
Capítulo 9 ■ O Toy Cat Figura 9-3. Ciclos dever de um servo Se você deseja enviar o servo para o neutro, a posição "zero", você enviá-lo de 1,5 ms no pulso a cada 20 ms, o que pode ser pensado como um ciclo de trabalho de 7,5%. Da mesma forma, se você quiser transformá-lo anti-horário com um 0,5-ms no pulso, tem um ciclo de serviço de 2,5%, e uma mais 2,5-MS no pulso traduz para um ciclo de trabalho de 12,5%. Em outras palavras, o servo é um dado De impulso "alto" para 2,5%, 7,5%, ou 12,5% do tempo. Estas instruções são aplicáveis a normalização não contínuo-servos. A diferença é que enquanto padrão servos usar o comprimento do impulso para determinar a sua posição final (em graus do centro), servos uso contínuo a duração do pulso para determinar a velocidade a que deve virar. Um servo standard irá se mover para seu destino posição e, em seguida, parar até que um novo comando é enviado; um servo contínua é quase sempre em movimento, com a velocidade de o movimento determinado pelos comprimentos de impulso. E enquanto você pode conseguir usar qualquer tipo de servo para o gato brinquedo, faz mais sentido usar servos padrão e, portanto, têm tanto a capacidade de posicionamento exato ea capacidade para parar completamente, permitindo que o gato-temporariamente, pelo menos- "pegar" o pequeno ponto vermelho. O problema com este método de movimento servos, no entanto, é que pode ser difícil utilizar o Pi e Python enviar pulsos milissegundo de comprimento para os pinos GPIO. Como todos os outros processos em execução no Pi, Python é constantemente sendo interrompido por processos em nível de sistema de funcionamento, fazendo sincronismo preciso de pulsos por um programa Python impraticável, para dizer o mínimo. No entanto, mais uma vez, a biblioteca GPIO tem o que precisamos: você pode usar a biblioteca para definir um GPIO pin como um pino PWM, dando-lhe o ciclo necessário dever de enviar os pulsos de comprimento correto para o pino. Assim, embora seja teoricamente possível roteiro algo como isto: while True: GPIO.output (11, 1) time.sleep (0,0015) GPIO.output (11, 0) time.sleep (0,0025) os resultados provavelmente seria algo completamente inesperado, se ele trabalhou em tudo. Em vez disso, o que nós podemos fazer é definir
pino do sinal de servo (pino 11 no nosso exemplo, o processo aqui) ser um pino de saída de PWM, inserindo p = GPIO.PWM (11, 50) A 50, neste caso, define os pulsos de 50 Hz (um impulso a cada 20 milissegundos), que é o que requer que o servo trabalho. Podemos, então, definir ciclo de trabalho do pino para 7,5%, digitando p.start (7,5)
Capítulo 9 ■ O Toy Cat Se colocarmos p.start (7.5) dentro de um loop while, o resultado é que o servo se moverá para a posição central e então permanecer lá. Alterar o ciclo de trabalho com p.ChangeDutyCycle () vai permitir-nos para mover o servo em diferentes direções, o que é o que nós estamos indo para com o brinquedo do gato. Assim, por exemplo, para ver o seu servo movimento frente e para trás, tente o seguinte script: importação RPi.GPIO como GPIO tempo de importação GPIO.setmode (GPIO.BOARD) GPIO.setup (11, GPIO.OUT) p = GPIO.PWM (11, 50) p.start (7,5) while True: p.ChangeDutyCycle (7,5) time.sleep (1) p.ChangeDutyCycle (12,5) time.sleep (1) p.ChangeDutyCycle (2,5) time.sleep (1) A execução deste script deve fazer a sua varredura servo e para trás, fazendo uma pausa para um segundo entre cada mudança de direção. Tudo o que resta para o nosso script de brinquedo de gato é implementar alguns números aleatórios. Esses números irão determinar qual move-se servo, em que direção, e por quanto tempo. O resultado deve ser um caminho bastante aleatória em duas dimensões. Construindo o Mecanismo Servo Nosso brinquedo de gato vai estar varrendo um ponteiro laser em duas direções, o que significa que precisamos de um servo capaz de o mesma coisa. Enquanto servos não são geralmente capazes de movimento 2-dimensional, podemos facilmente construir um pan e tilt servomecanismo usando dois servos normais ligados uns aos outros. ■ Nota Este procedimento irá ligar permanentemente os seus dois servos, tornando-os inseparáveis, para se certificar que você tem outros a usar para outros projetos. No entanto, lembre-se que uma configuração de pan e tilt como você está fazendo aqui é uma coisa útil para ter a projectos em que você precisa mover um item em duas dimensões, e você provavelmente vai usá-lo novamente. Então, não é como se você está destruindo os dois servos completamente. Tudo que você precisa fazer é montar o corpo de um servo para as pontas do outro. Para fazer uma conexão segura, você talvez seja necessário remover o parafuso que prende os chifres servo do servo base (vamos chamá-lo o servo do eixo X para manter a tarefa simples) e arquivar para baixo o plástico um pouco. Você está tentando alisar o topo do servo, tanto quanto possível para acasalarlo firmemente com o corpo do outro (eixo dos Y) de servo. Quando é tão plana como ele vai conseguir, use um epóxi forte ou adesivo para colar o corpo servo-eixo Y para as pontas do Servo-eixo-X. Eu usei Gorilla Glue e obteve o resultado na Figura 9-4.
Capítulo 9 ■ O Toy Cat Figura 9-4. Colados X e Y servos O ponteiro laser podem agora (depois de algumas modificações não tão pequenos) ser montado no topo (eixo Y) servo. Construindo o Mecanismo Laser Nós estamos indo para usar um ponteiro laser standard, mas nós estamos indo para modificá-lo em alguns aspectos importantes. O mais importante maneira é que em vez de usar baterias, vamos ligá-lo usando pinos GPIO do Pi. Isto é importante porque nos permite para ligar o laser e fora de forma programática, em vez de agitação com o interruptor de botão de pressão. Para modificar o ponteiro laser, você vai precisar de alguma fita isolante e um parafuso de cabeça chata cerca de duas polegadas de comprimento e com uma cabeça apenas um pouco menor do que o diâmetro interior do ponteiro laser. Enrole o parafuso com a fita isolante de modo que ele se encaixa confortavelmente dentro do ponteiro. Se necessário, quando estiver pronto, corte o final da fita (como mostrado na Figura 9-5) de modo que o ponto do parafuso é exposto. Figura 9-5. Mecanismo de parafuso para ponteiro laser
Capítulo 9 ■ O Toy Cat Retirar a base do ponteiro laser, e retire as pilhas. Aperte o parafuso, de cabeça, no corpo do ponteiro de modo que a cabeça do parafuso está empurrando para baixo a mola interna que é normalmente pressionada pelas baterias. Você pode ter que jogar com a quantidade de fita que você usa para embrulhar o parafuso; você quer que ele seja um ajuste apertado o suficiente para pressionar para baixo a mola e permanecer no local sem o perigo de se mover. Precisamos também de fita botão de energia do laser pointer para baixo de modo que é sempre ligado. Como eu disse, nós vamos cuidar de alimentar o ponteiro do Pi. Enrole um pedaço de fita adesiva ao redor do ponteiro para manter pressionado o botão. Neste ponto, você deve ter algo que se assemelha a imagem na figura 9-6. Figura 9-6. Mecanismo ponteiro laser Concluído Se você quiser testar o seu trabalho, use algumas garras jacaré para conectar o ponto do parafuso ao pino # 6 (o pino terra) sobre o Pi, e conecte o corpo do ponteiro ao pino # 1 (3.5V). O laser deve acender, mostrando que você está ligandodiretamente do pino de alimentação do Pi. Se nada acontecer, verifique se a cabeça do parafuso está pressionando a mola, o poder botão está firmemente gravada para baixo, e todas as suas conexões são sólidos. Uma vez que as ligações são sólidos, você está pronto para montar o laser para o seu servo maquineta bidimensional. Ligar o laser para o Servo Ligar o laser para o servo é provavelmente a parte mais fácil do projeto. Se você é como eu, você não quer anexar permanentemente a laser para a configuração servo pan e tilt que você tem, porque essa configuração pode vir a calhar com outros projetos também. Por isso, precisamos encontrar uma maneira de temporariamente anexar o laser para os chifres servo. Eu usei um palito de picolé para puxar esta off. Nós podemos colar a laser para o palito de picolé, e aperte o stick para o chifres servo. Isso pode ser feito tanto com os parafusos que vieram com o servo (você ainda tê-los, não é?) Ou a parafusos menores que você pode encontrar em sua oficina. Confie em mim, esses são realmente minúsculos buracos no chifre servo. Usando uma cola forte (mais uma vez, eu gosto Gorilla Glue), apor o conjunto do laser para o palito de picolé. Quando a área é seca, usar os pequenos parafusos para fixar o palito de picolé para os chifres servo. Quando estiver pronto, você deve ter um dispositivo que parece com a Figura 9-7.
Capítulo 9 ■ O Toy Cat Figura 9-7. Laser montado servos Uma palavra de cautela aqui: levar algum tempo e posicione o ponteiro laser e seu servo associado para que o laser pode girar livremente, não importa onde no ciclo os dois servos são. Obviamente, a maneira mais fácil de fazer isso é para remover o parafusos que prendem os chifres servo aos servos, e reposicionar os chifres com base em arcos de viagem dos servos. Em seguida, execute o dois servos através de todas as posições possíveis e certifique-se de que o seu mecanismo não se liga em qualquer ponto do seu movimento. Desde servos standard viajar apenas através de um arco de cerca de 180 graus, você deve ser capaz de encontrar uma posição adequada para todas as partes. A última parte integrante do presente projeto é ligar o sensor de movimento. Ligar o sensor de movimento Não só o sensor de movimento (mostrado na Figura 9-8) salvar suas baterias, mas também contribui fortemente para o frio fator: seu brinquedo é ativado apenas quando o seu gato (ou um cão, ou um colega de quarto, ou um Sasquatch) chega perto dela.
Capítulo 9 ■ O Toy Cat Figura 9-8. Sensor de Parallax IR Ligação do sensor IR é simples: os pinos positivos e negativos estão ligados ao poder, e o terceiro pino (o pino mais à esquerda na Figura 9-8) está ligado a um dos pinos GPIO do Pi configurado como uma entrada. Quando o sensor detectar movimento, ele gera um sinal de alta no pino de saída, que, em seguida, viaja para o pino de entrada do Pi. Com o GPIO pin configurado como uma entrada, podemos ler que o sinal e executar o script Python controlando o brinquedo apenas quando esse sinal está presente. Antes de continuarmos, eu preciso discutir o conceito importante de um pullup ou resistor suspenso. Sempre que você tem uma entrada em eletrônica, se essa entrada não está lendo nada diretamente, ela é referida como uma entrada flutuante. Que significa o valor lido do que a entrada poderia ser absolutamente nada. Precisamos definir estado "vazio" que de entrada de modo que nós vamos sabe quando essa entrada muda. Para definir o estado de "vazio" de uma entrada, normalmente conectar um resistor (10K ou 100K são valores comuns) entre o entrada e quer um pino positivo (criando assim um pullup resistor) ou um terreno (criando assim um suspenso resistor). Qual
aquele que você usa não é importante, é apenas importante que a entrada é puxado para cima ou para baixo. Assim, se nada está sendo lido em o pino, e está ligado a uma terra através de uma resistência suspenso, ele irá ler "0." Quando já não lê "0", nós saberemos que ele está recebendo de entrada. No caso do nosso sensor IR, precisamos definir o valor lido no pino quando nenhum movimento for detectado como "LOW", de modo vamos usar um resistor suspenso. Felizmente, para manter este processo simples, a biblioteca GPIO nos permite fazer isso no código, quando nós definimos um pino como uma entrada como esta: GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_UP) Se conectar o pino OUT do nosso sensor IR ao pino 11 sobre o Pi e inicializar que o pino com a linha de código anterior, leia tudo sobre o pino 11 será "LOW" até que seja detectado movimento. Nesse ponto, o pino vai ler "HIGH" e nós pode chamar a função que liga a laser e se move ao redor. Para testar o sensor e nossa força de codificação, vamos começar por definir os pinos GPIO em conformidade. Podemos usar um configuração simples para testar o nosso código; um LED em uma placa de ensaio que se acende quando o sensor é acionado. Em um script Python, entrar e salvar o seguinte código: importação RPi.GPIO como GPIO tempo de importação GPIO.setwarnings (False) #eliminates lancinante da biblioteca GPIO.setmode (GPIO.BOARD) GPIO.setup (11, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup (13, GPIO.OUT)
Capítulo 9 ■ O Toy Cat while True: Se GPIO.input (11): GPIO.output (13, 1) outro: GPIO.output (13, 0) Isso é tudo para o código de teste! Para testar o código ea configuração do sensor, primeiro conecte o pino (+) sobre o sensor ao pino # 2 na o Pi. Conecte o pino OUT ao pino # 11 sobre o Pi. Conecte o - pin a uma linha de base comum sobre a sua placa de ensaio (). Finalmente, conectar o pino nº 13 do Pi para a perna positiva de sua LED, e se conectar a perna negativo do LED (através de um resistor) para a linha de base comum. Você deve acabar com algo parecido com a configuração que você vê na figura 9-9. Figura 9-9. Sensor IR e configuração de teste LED ■ Nota A imagem na Figura 9-9 foi criado com Fritzing (http://www.fritzing.org), uma grande open-source breadboarding ferramenta / design. É multi-plataforma, muito fácil de usar e aprender, e altamente recomendada. Quando você executar o script (lembrando-se de executar o código como o superusuário ou sudo, uma vez que você está acessando os pinos GPIO), o LED deve acender quando você mover sua mão ao redor do sensor, e depois ir para fora outra vez depois de algumas segundos de não movimento. Se isso não funcionar, verifique as conexões e suas peças-a-fora queimado LED pode causar todos os tipos de dores de cabeça de solução de problemas, acreditem!
Se tudo funcionar como planejado, agora podemos ligar o brinquedo e completar todas as conexões.
Capítulo 9 ■ O Toy Cat Conectando todos os bits Depois de testar com sucesso o sensor de infravermelho, o código necessário para operá-lo, e o código utilizado para trabalhar a servos, e quando tudo está ligado a tudo o resto, é hora de ligar tudo e fazer todas as conexões. Este é o lugar aonde uma pequena placa de ensaio vem a calhar, porque você pode conectar todos os seus fundamentos em conjunto (um absoluto necessidade) e poder de execução para tudo, conforme necessário. Eu usei uma bateria de 9V para os dois servos, mas sinta-se livre para tentar diferente baterias como você preferir. Não é necessário o uso de uma bateria recarregável RC, neste caso, como fazemos em alguns outros projetos, porque o peso não é realmente um problema e os servos não executar a bateria para baixo muito rápido, como eles não estão constantemente rodando graças ao sensor. No entanto, você não precisa para alimentar os servos com uma fonte separada da que você está usando para alimentar o Pi; caso contrário, você vai ter congela e falhas constantes. Com uma placa de ensaio que tem dois energia canais, você pode executar o + 9V para baixo um canal positivo, conectar o pino # 2 sobre o Pi para o outro canal positivo, e em seguida, ligar os dois negativos juntos. Então você pode se conectar a potência do laser e do poder sensor IR ao poder do Pi canal e conectar os dois servos para o canal de energia 9V, e todos os seus fundamentos serão amarrados. Ver Figura 9-10, que mostra as várias partes ligadas em conjunto, utilizando uma placa de ensaio. Figura 9-10. Interconexões componente final
Capítulo 9 ■ O Toy Cat Figura 9-10 não é totalmente preciso porque o ponteiro de laser é suposto ser anexado ao servos, mas você começa a idéia geral. O ponteiro é alimentado com o pino # 11, os servos são alimentados com alfinetes # 13 e # 15, # 19 e pin é a entrada do sensor. Então, tudo é dado a respectiva tensão para fazê-lo funcionar. Existem algumas tarefas mecânicas de engenharia envolvidas na construção deste brinquedo, não menos do que é o melhor maneira de anexar permanentemente os fios de alimentação e de terra para o ponteiro laser. Enquanto pinças são muito bem para os ensaios, de Assim que os servos começar empurrando o ponteiro em círculos, eles estão indo para ser desfeito. A melhor solução para isto é a soldar os fios para as peças de ponteiro. Se você puder, use uma lixa para tornar áspero o ponto do parafuso e a carcaça ponteiro. Se você tiver espaço, faça um pequeno furo no revestimento ponteiro para segurar o fio positivo. Em seguida, anexar os seus fios e solda tudo. Seus resultados podem variar, dependendo de suas habilidades de solda e da materiais com os quais você está trabalhando. Você ainda pode usar cola, desde que você não conseguir cola entre os contatos de metal dos fios e peças de ponteiro. É importante que todos os fios tem uma conexão boa e sólida. O último passo é montar o dispositivo inteiro em algum tipo de recipiente para manter tudo no lugar e para proteger as entranhas de a máquina de investigação felino. Pode manter todas as partes breadboarded, enquanto este está protegido a partir da extremidade usuário (seu gato.) I tendem a usar tubos de PVC em casos como estes, porque um servo padrão se encaixa quase perfeitamente em um de 2 polegadas Tubo de PVC ID. Neste caso, você pode montar o servo mais baixo para a borda do tubo, ea maioria dos fios e coragem pode ser arrumadas de forma segura dentro dela, com um furo na lateral para o sensor infravermelho. O Pi não vai caber, mas pode ser com segurança arrumadas em uma caixa separada, ligada ao conjunto de tubo através de fios jungir longos. Com sorte, você acabar com um brinquedo do gato que é algo como Figura 9-11. Figura 9-11. Concluído brinquedo de gato Capítulo 9 ■ O Toy Cat Não é bonito, mas o seu gato não vai se importar. Pode ser gussied, é claro, com uma tampa sobre a extremidade do tubo e uma camada de tinta. Provavelmente, o detalhe mais importante para se lembrar (e não é mostrado aqui) é esconder a coragem e fios de olhos curiosos (e patas). O tubo de PVC que usei aqui é muito estreita, mas um tubo com uma secção transversal maior poderia facilmente ser equipado com o Pi e todas as outras vísceras dentro dele, fazendo uma unidade auto-contida. Então você pode adicionar um interruptor de alimentação para o exterior, e está pronto para ir. Que deve ser isso! Executar o script cat_toy.py agora deve manter seu amigo felino (e muito possivelmente o seu os humanos) entretido por horas. Vale a pena notar que agora você tem o conhecimento ea capacidade de apontar e disparar um laser com o Raspberry Pi. Sim, é uma míseros pouco ponteiro laser, mas o conceito pode ser facilmente aplicada a qualquer laser, independentemente do tamanho ou poder. Qualquer laser. Divirta-se!
O código final Este código, disponível no site da Apress.com como cat-toy.py, configura os pinos de saída GPIO, sementes aos números aleatórios geradores e, em seguida gira os servos e acende o laser em movimentos aleatórios. importação RPi.GPIO como GPIO tempo de importação importação aleatória random.seed () pins #set GPIO.setmode (GPIO.BOARD) GPIO.setwarnings (False) GPIO.setup (11, GPIO.OUT) poder #laser GPIO.setup (13, GPIO.OUT) # X servoGPIO.setup (15, GPIO.OUT) # Y-servo GPIO.setup (19, GPIO.IN, pull_up_down = GPIO.PUD_UP) #in de IR #setup servo PWM p = GPIO.PWM (13, 50) q = GPIO.PWM (15, 50) #set ambos os servos até o centro para começar p.start (7,5) q.start (7,5) def moveServos (): "Acende a laser e move X e Y-servos aleatoriamente" lightLaser () p.ChangeDutyCycle (random.randint (8, 12)) time.sleep (random.random ()) q.ChangeDutyCycle (random.randint (8, 12)) time.sleep (random.random ()) p.ChangeDutyCycle (random.randint (3, 5)) time.sleep (random.random ()) q.ChangeDutyCycle (random.randint (3, 5)) time.sleep (random.random ()) dimLaser () Capítulo 9 ■ O Toy Cat def lightLaser (): GPIO.output (11, 1) def dimLaser (): GPIO.output (11, 0) laço #main while True: #check para a entrada do sensor Se GPIO.input (19): moveServos () time.sleep (0,5) #WAIT meia sec antes sensor de polling outro: dimLaser () time.sleep (0,5) Resumo Neste cCapítulo, você construiu com sucesso um mecanismo servo de dois eixos, cortou um ponteiro laser para ser demitido pelo Raspberry Pi, e usou suas habilidades de programação para apontar aleatoriamente e disparar o laser para entreter seu gato. No próximo cCapítulo, vamos obter o seu Pi para fora da casa e enviá-lo para o céu em um avião controlado por rádio.
Capítulo 10 O avião controlado por rádio Muitos de nós têm muito tempo sonhava em vôo de voar através do ar, livre como um pássaro. Ou, como o piloto John Magee Jr. colocou, deslizando as "ligações surly da Terra. . . ", Dançando através dos céus" nas asas lisas e prateadas, "e no topo" da alturas varridas pelo vento com graça fácil ". Infelizmente, deslizando as ligações surly da terra, muitas vezes leva tempo e dinheiro que não temos, e isso pode
explicar, em parte, o advento do (RC) do avião controlado por rádio. Embora possamos não ser capaz de suportar terra ou vôo escola, uma escala 1:12 Piper Club pode ir um longo caminho para tornar-nos sentir menos fundamentada, e nós temos a oportunidade de pilotar um avião real sem ter de pisar fora de terra firme. O problema, porém, é que, enquanto nós podemos controlar o avião do chão, não é completamente como realmente estar há. Embora existam complicados, caros maneiras de prender uma pequena câmera de vídeo no seu plano de RC, que seria bom se você poderia fazer algo semelhante com o Pi. E isso seria muito legal se você pudesse manter o controle de seu vôo, e depois carregar as coordenadas para o Google Earth para ver o que o seu vôo parecia. Bem, neste projeto que você pode fazer exatamente isso. O plano para este projeto é colocar o Pi e um receptor GPS a bordo de um Plano de RC e, em seguida, voar. A câmera do Pi vai tirar fotos durante o vôo, e o GPS irá registrar os dados de localização. Depois, quando você voltar para casa, você vai usar um script Python para analisar os dados de localização em um arquivo KML que você pode fazer o upload para Google terra ■ Nota Este cCapítulo contém alguns conceitos avançados de programação, talvez mais avançados do que qualquer coisa que você tem deparamos até agora, como fios e até mesmo um pouco de programação orientada a objetos (OOP). Mas eles não são terrivelmente complicado, e eu vou explicar os conceitos que possam surgir. A Lista de Compras de Peças Embora este projeto não requer muitas partes, ele pode realmente ser o projeto mais caro para construir neste livro, porque requer um, (RC) do avião rádio-controlado de médio porte. Aqui estão algumas peças adicionais que você vai precisar: • Raspberry Pi (com câmera) • Receptor GPS (https://www.adafruit.com/products/746) • Antena para o receptor (opcional) (https://www.adafruit.com/products/851) • tamanho médio RC avião • RC bateria e regulador de 5V para alimentar o Pi
Capítulo 10 ■ O Avião Rádio-Controlado Se acontecer de você já ser um entusiasta RC, você provavelmente vai ter um plano que você pode usar, mas se você é novo para o esporte, você vai precisar comprar um bom plano de partida. Como amador, posso recomendar um bom novato de plane-o Switch, por FlyZone (mostrado na Figura 10-1). Figura 10-1. O Switch (Imagem © FlyZone Planes em http://www.flyzoneplanes.com) Este plano é resistente o suficiente para suportar algumas falhas quando você aprender a voar, firme o suficiente para ser pilotado por um novato absoluto, é o mais importante-ser poderoso o suficiente para suportar o peso extra de um Pi, receptor GPS, ea bateria para alimentar os dois. Seu nome vem do fato de que, como você se tornar mais aptos a voar, você pode remover as asas da configuração estável "top" e mudá-los para uma configuração "mid" mais baixo para mais acrobático manobras. Como você verá, a configuração "top" é perfeito não só porque é fácil para iniciantes, mas porque o Pi e GPS pode sentar-se confortavelmente no topo da asa. Pronto? Vamos começar criando um diretório para o nosso programa avião: plano mkdir e depois navegar nela, digitando cd. Agora vamos começar a Pi para se comunicar com o nosso dispositivo GPS. Ligar o receptor GPS para o Pi Para obter o seu Pi falar com o receptor GPS, primeiro você precisa conectar os dois. Para fazer isso, nós vamos usar a biblioteca Python chamado gpsd, e UART do Pi (Universal Asynchronous Receiver / Transmitter) de interface (pinos 7 e 8). O Python gpsd módulo é parte de uma biblioteca maior de código concebido para permitir que dispositivos tais como a Pi para monitorar GPS ligado e receptores AIS, com portas para C, C ++, Java e Python. Ele permite que você "ler" o National Marine Electronics Association (NMEA) -formatted dados transmitidos pela maioria dos receptores GPS.
Capítulo 10 ■ O Avião Rádio-Controlado A interface UART é antiga. É basicamente uma conexão serial (RS-232), mas para os nossos propósitos é tudo que precisamos. Ele consiste em um positivo (+) e negativo (-) de conexão para energia e transmitir e receber pinos. Comece digitando o seguinte linha para instalar o software que você precisa para ler o GPS, gpsd e seus programas associados: sudo apt-get install DSGP-clientes DSGP python-gps Em seguida, precisamos configurar a interface UART do Pi. Por padrão, ele está configurado para se conectar a uma janela de terminal, mas nós precisa de comunicar com o Tx e Rx (transmissão e recepção) dos pinos. Para fazer isso, primeiro fazer uma cópia de /boot/cmdline.txt digitando sudo cp /boot/cmdline.txt /boot/cmdlinecopy.txt e depois editá-lo digitando sudo nano /boot/cmdline.txt. Excluir a seguinte parte console = ttyAMA0,115200 kgdboc = ttyAMA0,115200 para que o arquivo lê dwc_otg.lpm_enable = 0 console = tty1 raiz = / dev / mmcblk0p2 rootfstype = ext4 elevador = prazo rootwait Salve o arquivo, e em seguida, editar o arquivo inittab digitando sudo nano / etc / inittab Comente a seguinte linha (a última linha), que conta a Pi para iniciar uma ligação terminal, adicionando um hashtag para o início da linha: # T0: 23: de respawn: / sbin / getty -L ttyAMA0 115200 vt100 Agora reinicie digitando sudo shutdown -r now. Quando você está de volta instalado e funcionando, conecte o receptor de GPS para o Pi assim: 1. Conecte VIN do receptor para 5V do Pi (pino # 2). 2. Conecte o GND para Pi pin # 6. 3. Conecte o Tx a Rx Pi (pino # 10). 4. Conecte o Rx de Pi Tx (pino # 8). Quando o LED do receptor começa a piscar, você sabe que tem poder. Agora você pode testá-lo iniciando o gpsd programa digitando sudo gpsd / dev / ttyAMA0 -F /var/run/gpsd.sock Em seguida, iniciar o cliente GPS genérico, digitando CGPS -s O cliente CGPS é um visualizador genérico; ele simplesmente pega os dados do programa gpsd está recebendo e exibe-lo para o usuário. Pode demorar um momento para dados para começar a transmitir, mas quando isso acontece, você deve ver uma tela como a da Figura 10-2.
Capítulo 10 ■ O Avião Rádio-Controlado Figura 10-2. O fluxo CGPS Se você não vê nada, mas zeros, isso significa que o GPS não consegue encontrar uma solução por satélite. Você pode ter que esperar alguns minutos ou até mesmo dar o GPS uma visão clara do céu. Minha experiência é que esta placa GPS particular, mesmo sem o opcional antena, é muito sensível. Quando eu adicionei a antena, eu não tinha problema obter um sinal GPS, mesmo em minha casa. Depois de saber que a unidade GPS está funcionando e se comunicando com o Pi, é preciso colocar essa informação em um formato que pode usar em um arquivo de log. Embora o cliente genérico, CGPS, que usamos aqui é útil para visualizar coordenadas, infelizmente é muito difícil obter informações úteis a partir dele. Por esta razão, vamos usar o módulo GPS para Python interagir com o receptor. ■ Observação O gps módulo permite que você se comunique com muitos receptores GPS diferente, não apenas o que estamos usando em este projeto. Existem alguns receptores que geram fluxos de dados proprietárias, mas a maioria deles de saída da mesma Dados NMEA-formatado como o chip que estamos usando aqui. Configurando um arquivo de log Quando chegarmos a corrente do GPS, nós precisamos de ter um lugar para armazená-lo para uso posterior, como ele não vai fazer-nos muito bom se nós estamos apenas imprimi-lo a um (nonconnected) tela durante o vôo. O que podemos fazer é criar um arquivo de log, usando Python de registrando módulo e, em seguida, quando o Pi está de volta no chão, podemos analisar o arquivo e colocá-lo em um formato que pode usar
no Google Earth. Configurando o arquivo de log é muito simples. Comece digitando logging importação logging.basicConfig (filename = 'locations.log', nível = logging.DEBUG, format = '% (message) s') Estas duas linhas de importar o módulo, declare nome do arquivo de log e do que é registrado, e dar o formato de cada linha. Vamos guardar cada chamada GPS em três textos: a longitude, latitude e altitude, as três coordenadas utilizado pelo Google terra. (Eles estão realmente salvos como carros alegóricos, e não cordas, o que significa que nós vamos ter que convertêlos em cadeias . quando escrevê-las no arquivo de log) Para escrever uma linha no arquivo de log, o formato é simplesmente esta: logging.info ("logado mensagem ou string ou que-ter-você")
Capítulo 10 ■ O Avião Rádio-Controlado Não é necessário usar o caractere de nova linha (\ n), porque cada vez que você chamar a função logging.info (), ele começa em uma nova linha. No caso você esteja se perguntando, sim, nós podemos simplesmente escrever os dados do GPS em um arquivo regular, mas o registro é um importante, conceito útil que muitos programadores não entendem completamente ou ignorar completamente. No caso do Python registrando módulo, você pode configurar entradas de registro a ser introduzidos, dependendo da gravidade do evento que está sendo rastreado. tem cinco severidades possíveis: debug, info, aviso, erro e crítico.
OS CINCO gravidades (níveis) Enquanto eu estou usando o termo 'gravidades, "para descrever entradas de log talvez" níveis "pode ser um termo melhor. Quando um executa programas (não importa o idioma é escrito em), que normalmente gera eventos que podem ser registrados por o módulo de registro. Eventos de depuração são detalhados e são normalmente usados apenas para diagnosticar problemas. Eventos Info são confirmações de que as coisas estão funcionando corretamente. Eventos de aviso não apenas isso: eles alertam que enquanto as coisas ainda estão trabalhando, pode haver um problema em um futuro próximo. Eventos de erro e crítico acontecer apenas quando algo quebra, e CRÍTICA normalmente significa que o programa não pode continuar a trabalhar. O nível padrão AVISO é, o que significa que, se você definir a sua função de registro de forma diferente, eventos dada uma depuração ou INFO gravidade (porque eles estão abaixo AVISO) não será registrada. Para ver o módulo de registro em ação, tipo de python para iniciar um prompt de Python e digite o seguinte: >>> Log de importação >>> Logging.warning ("Eu sou um aviso.") >>> Logging.info ("Eu sou uma informação.") A segunda linha de saída vontade AVISO: root: Eu sou um aviso, enquanto a terceira linha, classificada como nível INFO, vontade não ser a saída para o console. Se, por outro lado, você entra >>> Logging.basicConfig (nível = logging.DEBUG) ele define o nível padrão de depurar, o que significa que cada evento será registrado ou saída, independentemente da gravidade. Entrando o nome do arquivo e formato, como fizemos anteriormente, define o arquivo de log e como os eventos são gravados. ■ Nota Registrando eventos é uma habilidade importante saber para qualquer programador; se você quiser saber mais sobre logging do Python módulo de forma mais aprofundada, eu recomendo que você leia a documentação Python em http://docs.python.org/2/howto/ logging.html. A formatação de um arquivo KML Um arquivo KML é um tipo especial de XML (eXtensible Markup Language) utilizado pelo Google Earth para delinear pontos de referência, objetos, e até mesmo caminhos. Ela é semelhante a um arquivo HTML, com abertura e fechamento <> marcas para diferentes níveis de informações, como
Capítulo 10 ■ O Avião Rádio-Controlado isso é muito fácil, uma vez que formatado o arquivo de log só tem longitude, latitude e alti tude, separados por espaços-com format = '% (message) s' e) linha (logging.info. Agora podemos analisar cada linha no arquivo de log, separá-lo por espaços com string.split, e escrevê-lo em um arquivo .kml pré-formatado. Ao usar o write () função, podemos escrever cada linha para o novo arquivo, chamado "kml" no script, assim: kml.write ('
Figura 10-3. Arquivo KML no Google Earth
Capítulo 10 ■ O Avião Rádio-Controlado Lembre-se que porque estamos apenas polling a unidade GPS a cada 30 segundos, não teremos uma linha curva agradável. Em vez disso, o caminho vai ligar os lugares onde o avião estava a esses intervalos, e as conexões serão retos linhas. Como você pode ver na Figura 10-3, eu usei um parque de estacionamento para o meu teste de vôos de meu conselho para um flyer começando é usar um campo gramado, se puder, como pousos forçados na grama são susceptíveis de ser mais fácil em seu avião! Tudo no Alasca estava coberta pela neve durante os meus vôos de teste, por isso realmente não importa onde eu testei as coisas.
Usando threading e Objetos Uma característica importante de programação que vamos usar neste programa é threads. Você pode tê -los visto antes; eu até usá-los em um ou dois dos outros projectos neste livro. Tópicos são importantes porque permitem que o seu programa e processador para fazer várias tarefas ao mesmo tempo, e eles não amarrar toda a memória e poder de processamento fazendo uma simples tarefa. Uma simples chamada para importar rosqueamento lhe dá o poder cheio de tópicos e todos eles podem fazer por você. O QUE THREADS realmente fazer? Threads permitir que seu computador (aparentemente) executar várias tarefas ao mesmo tempo. Digo "aparentemente" porque a processador ainda pode executar apenas um processo por vez, mas threads permitir que ele alternar entre processos tão rápido que parece ser executá-los simultaneamente. Como exemplo, digamos que você está trabalhando em seu computador, com um processador de texto aberto em uma janela e um navegador de Internet aberto em outro. Embora a palavra corridas de processadores em um thread, outro thread (firmado entre seus traços essenciais) mantém o seu navegador atualizado, ainda outro verifica seu cliente de email para novas mensagens, e assim por diante. O que nós vamos fazer com eles neste programa é usá-los para pesquisar o receptor GPS. Usando um fio, a página tampão não vai encher-se com os dados à medida que continuamos a obter dados, mas ainda podemos registrar os dados no nosso arquivo de log para uso posterior. Para usar segmentos da maneira mais eficiente possível, nós vamos criar um objeto chamado Poller que irá solicitar informações do GPS receptor de vez em quando (digamos que a cada três segundos), utilizando o módulo GPS. Toda vez que uma leitura posição, vamos atualizar o registro e tirar uma foto.
Objetos, classes e funções, OH MEU! Direito aproximadamente agora, você provavelmente está começando a surtar um pouco: "Objetos? Classes? O que ele está falando? "Citando Douglas Adams, "Não entre em pânico." Considere isso uma tarefa fácil, não-estressante introdução à programação orientada a objetos (OOP). Pense em uma classe como um conjunto de objetos similares que compartilham certas características. Por exemplo, quadrados, triângulos, e pentágonos são todos os membros da forma de classe têm os lados, um perímetro calculável e uma área calculável. Um objeto é um membro em particular, ou exemplo, da classe que: myRectangle, por exemplo, é um exemplo da certo moldar classe. Quando você define uma classe, você define suas características, tais como o fato de que a forma tem lados e é uma fechada objeto. Você também pode definir as funções que são exclusivas para essa classe. Para ilustrar, cada membro da forma classe pode ter uma função definida que especifica como calcular o seu perímetro. Este cálculo pode variar de acordo com a o indivíduo forma objeto, por isso é exclusivo a esse objeto, mas cada forma objeto tem um defineArea () função. O segmento que criamos em nosso programa final conterá um objeto-membro da Rosca de classe com um conjunto de variáveis e funções únicas para ele. Então, quando nós começamos nossa discussão, ele terá uma função de polling GPS associado que vai lidar com a recuperação de localização e tira uma fotografia.
Capítulo 10 ■ O Avião Rádio-Controlado Nosso objeto de discussão será definido da seguinte forma: myObject classe (threading.Thread): def __init __ (self): #function usado para iniciar a classe e linha threading.Thread .__ o init __ (self) #necessary para iniciar o segmento run def (self): #function realizada enquanto thread está sendo executado A partir da parte principal do programa, podemos começar a discussão declarando um novo objeto myObject (um novo tópico): newObject = myObject () e depois iniciá-lo com newObject.start () O segmento está funcionando agora com a sua própria instância de myObject, chamado newObject. O nosso rosca (como mostrado na o código final, no fim do cCapítulo) será iniciado com threading.Thread .__ o init __ (self). Uma vez que tenha sido iniciado, ele vai continuar a executar a sua função (no nosso caso, a recolha de dados GPS e tirando fotos) até que saia o programa. Configurar inicialização automática Porque é provável que nós não terá um monitor ou teclado conectado quando ligar o Pi antes de prendê-lo ao plano, vamos precisar ter certeza de que o nosso script de registro GPS é iniciado automaticamente. A maneira mais fácil de fazer isso é adicionar uma entrada para o arquivo /etc/rc.local (como explicado na barra lateral "O que é o arquivo rc.local?"). No nosso caso, se o nosso GPS código de log é chamado getGPS.py, e ele é armazenado em nossa pasta Documents / avião, podemos adicionar a linha /home/pi/Documents/plane/getGPS.py para o arquivo rc.local. Abra-o com sudo sudo nano /etc/rc.local e adicione a linha python /home/pi/Documents/plane/getGPS.py para o arquivo, antes da última saída 0 linha no arquivo. Capítulo 10 ■ O Avião Rádio-Controlado O QUE É O rc.local? O rc.local arquivo é uma parte padrão do kernel do Linux. É um dos inicialização do sistema rc arquivos e reside no / etc / diretório. Depois que o kernel inicializa todos os dispositivos na inicialização, ele atravessa os rc arquivos um por um, correndo os scripts contidas em cada um. O rc.local arquivo é o último a correr e contém scripts que não se encaixam em qualquer dos outros arquivos. Por esta razão, este arquivo é editável pelo administrador do sistema e é frequentemente utilizado (como é aqui) para manter scripts que precisam ser executados sempre que o computador é iniciado. Um detalhe importante para lembrar sobre a adição de scripts neste arquivo que é porque ele não é executado como qualquer determinado usuário, você deve dar o script completo caminho, não apenas ~ / Documents / myscript.py, por exemplo. No entanto, isso não é tudo o que precisamos fazer. Antes do programa GPS vai mesmo trabalhar, temos de ligar a alimentação GPS novamente, como fizemos quando estávamos a testar o cliente GPS genérico (anteriormente em "Conectar o receptor GPS para o Pi"). assim é preciso colocar essa linha em /etc/rc.local: sudo gpsd / dev / ttyAMA0 -F /var/run/gpsd.sock Finalmente, temos de esperar para a unidade GPS para obter uma correção em alguns satélites antes de iniciar o registro, caso contrário, vamos estar registrando um monte de 0.0,0.0, nan coordenadas. (A nan significa não um número.) Minha experiência é que leva cerca de 30 segundos para a unidade para obter uma correção e começar a retornar dados reais, portanto, esperar 45 segundos antes de iniciar o script é provavelmente seguro. Para isso, basta colocar 45 sono após a linha gpsd sudo você acabou de adicionar, e o sistema irá esperar 45 segundos antes de iniciar o script Python no próxima linha. Quando estiver pronto, o arquivo /etc/rc.local deve terminar assim: sudo gpsd / dev / ttyAMA0 -F /var/run/gpsd.sock
45 sono python /home/pi/Documents/plane/gpstest.py Salvar e sair, e o script será executado na inicialização. Ligação dos Bits Depois de ter o plano, a construção deste projeto é relativamente fácil. Você vai precisar de uma bateria para o Pi e um regulador para fazer se você não está dando-lhe muito suco. Eu particularmente sou fã das baterias Li-Po (mostrado na Figura 10-4) que RC Os adeptos de usar, porque eles são leves e embalar um lote de potência em um pacote pequeno. Os que eu uso me dar 1.3A para um hora-muito mais do que eu preciso.
Capítulo 10 ■ O Avião Rádio-Controlado Figura 10-4. Lithium Polymer (Li-Po) baterias Para o regulador de tensão, Eu cortei um carregador de carro USB, como mostrado na Figura 10-5. Figura 10-5. Carregador de carro Hacked
Capítulo 10 ■ O Avião Rádio-Controlado O terminal do meio vai para (+) da bateria de chumbo, e um dos terminais exteriores vai ao GND. Em seguida, um simples Cabo USB fica conectado ao Pi, e você tem o poder. Quando se trata de colocar tudo no avião, é uma espécie de miscelânea. Os detalhes importantes para lembrar são para manter o avião equilibrado, e não interromper o fluxo de ar para cima das asas. Eu coloquei o GPS no nariz, e gravou o Pi para as linhas laterais. É meio difícil de ver na foto na Figura 10-6, mas a câmara está colado na asa porta, apontou para o chão. Logo atrás da asa você pode ver o plugue USB que será conectado ao Pi. Os olhares Instalação concluída desajeitado, mas ele voa muito bem. Figura 10-6. Uma visão geral da configuração Figura 10-7 mostra como I anexa a unidade GPS para o nariz do avião. Figura 10-7. Um close up da unidade de GPS no nariz do avião
Capítulo 10 ■ O Avião Rádio-Controlado Figura 10-8 mostra como I anexa o Pi a asa do avião. Figura 10-8. Um close up de Pi na asa do avião Quando você está pronto para ir e ter feito todas as suas pré-voo verificações, ligue o Pi e esperar 45 segundos para o plane.py roteiro para iniciar e para a unidade GPS para adquirir alguns satélites. Em seguida, retire e obter algumas ótimas fotos! Quando você está de volta para casa com o Pi, faça o login para ele e executar o script de conversão .kml, chamado kml.py aqui. Esse script abrirá o arquivo locations.log criado pelo script plane.py, analisar o seu texto, e escrever todos os seus locais incluídos em um arquivo .kml válido, chamado plane.kml. Você pode então transferir o arquivo para qualquer computador com o Google Earth instalado. Quando ele é carregado em seu computador, clique com o botão direito sobre o arquivo e abra o "Abrir com. . ." cardápio. Localizar "Google Earth" nas opções do programa e clique em Abrir (como mostrado na Figura 10-9).
Capítulo 10 ■ O Avião Rádio-Controlado Figura 10-9. Plane.kml Abertura com o Google Earth em um Mac Quando o arquivo é carregado, você vai ter uma imagem como a do estacionamento na Figura 10-3 no início do cCapítulo. o fotos tiradas por sua câmera, por sua vez, estará localizado na mesma pasta que o arquivo gpstest.py ou onde quer que você especifique em seu script. (Veja o código final no final deste cCapítulo para obter um exemplo.) Aqui vai uma dica final: Porque você colocar o script gps no seu arquivo /etc/rc.local, ele vai continuar a iniciar cada vez você ligar até que você remova essa linha do arquivo. Se você quer matar o script gps para que ele não está funcionando no fundo e utilizando recursos do processador, mas você não tenha chegado a cerca de excluir a sua linha de rc.local, tipo topo em um terminal. Este comando mostra todos os processos actualmente em execução no Pi. Para parar o script Python, procure um processo intitulado "python" e observe o PID (ID do Processo) na primeira coluna. Pressione "Q" para sair topo, em seguida, digite sudo matar xxxx onde xxxx é o PID que anotou anteriormente. Isso vai matar o script Python até que você remova sua linha de rc.local e reiniciar. O código final O código final é composta de duas partes: o programa de avião e o programa de conversão de KML. Capítulo 10 ■ O Avião Rádio-Controlado O Programa plano Esta parte do programa é o que é executado enquanto o avião estiver no ar, tirando fotos e registrando coordenadas GPS. É do disponível como plane.py de Apress.com:
import os gps de importação * do tempo de importação * tempo de importação rosqueamento de importação logging importação de subprocess chamada de importação #set up do arquivo de log logging.basicConfig (filename = 'locations.log', nível = logging.DEBUG, format = '% (mensagem) s') picnum = 0 gpsd = None classe GpsPoller (threading.Thread): def __init __ (self): #initializes fio threading.Thread .__ o init __ (self) gpsd mundial gpsd = gps (mode = WATCH_ENABLE) self.current_value = None self.running = True run def (self): #actions feita pelo fio gpsd mundial enquanto gpsp.running: gpsd.next () E se __name__ == '__main__': #if na seção principal do programa, GPSP = GpsPoller () #start um fio e iniciar o registro experimentar: #e tirar fotos gpsp.start () while True: #log de localização GPS logging.info (str (gpsd.fix.longitude) + "" + str (gpsd.fix.latitude) + "" + str (gpsd.fix.altitude)) #save imagem numeradas no diretório correto ligue para (["raspistill -o / home / pi / Documents / plano / imagem" + str (picnum) + ".jpg"], shell = True) picnum = + 1 picnum número de imagem #increment time.sleep (3) exceto (KeyboardInterrupt, SystemExit): gpsp.running = False gpsp.join ()
Capítulo 10 ■ O Avião Rádio-Controlado Programa de Conversão KML Este programa é executado quando o Pi está de volta no chão. Leva o arquivo de log GPS e converte-lo para um arquivo KML. É do disponível como kml.py de Apress.com: import string #open arquivos para leitura e escrita gps = open ('locations.log', 'r') kml = open ('plane.kml', 'w') kml.write (' xml version = "1.0" encoding = "UTF-8"?> \ n') kml.write ('