Detecção de relâmpagos com um Raspberry Pi

Métodos diversos podem ser usados ​​para detectar relâmpagos. Normalmente envolve a detecção da radiação eletromagnética gerada por um ataque. A maioria das pessoas provavelmente já ouviu isso em algum momento como estática, estalos e sons de estouro em um rádio AM. Alguns detectores são capazes de captar os flashes de luz produzidos dentro de uma nuvem, mesmo durante o dia, quando geralmente não podem ser vistos pelo olho humano devido à luz solar. Ocasionalmente, o relâmpago emitirá um breve pulso de radiação gama - algo que um novo instrumento a bordo da Estação Espacial Internacional está programado para estudar.

Neste post, explorarei o uso de um RaspberryPi para fazer a interface com o CI do Sensor de Relâmpago Franklin AS3935 da ams (Austria Mikro Systeme). O AS3935 é um sensor programável que pode detectar a atividade de raios a até 40 km de distância. Ele usa um algoritmo patenteado para filtrar ruídos e “perturbadores” feitos pelo homem e estimar a distância até a borda da tempestade; tem níveis de detecção programáveis, configurações de limite e sintonização de antena; e, ao contrário de muitos sensores de relâmpagos terrestres anteriores, podem detectar atividade de relâmpagos nuvem-solo e dentro de nuvens.

Os detalhes

Em vez de arredondar os componentes específicos em pequenas quantidades, criar um PCB e tentar soldar manualmente o pacote MLPQ-16, um tanto pequeno (4x4 mm), usei a placa breakout MOD-1016 da Embedded Adventures. O AS3935 requer uma faixa de tensão de alimentação de 2,4 - 5,5 V, que funcionará perfeitamente com os níveis lógicos GPIO de 3,3 V do RaspberryPi. Ele pode ser conectado por meio de SPI ou I2C. Por padrão, o MOD-1016 vem configurado para usar I2C, mas pode ser facilmente alternado para usar SPI por meio de alguns jumpers de solda na placa. Em minha configuração, continuarei com a configuração I2C padrão.

Este projeto serviu como uma boa introdução ao protocolo I2C para mim. Eu já tinha usado o protocolo 1-Wire antes para fazer a interface de alguns sensores de temperatura DS18B20, mas o I2C é muito mais usado e fiquei feliz por ter a oportunidade de mergulhar nele. Neste post, estarei cobrindo os detalhes necessários para se comunicar com o AS3935 do RaspberryPi sobre I2C, mas se você quiser mais informações, Byte Paradigm fornece uma introdução maravilhosa a I2C e SPI.

Se você ainda não configurou o RaspberryPi para usar o protocolo I2C, será necessário instalar alguns pacotes e carregar alguns módulos do kernel. Adafruit tem um guia maravilhoso aqui, mas basicamente você só precisa instalar o python-smbus e i2c-tools pacotes e carregue o i2c-bcm2708 e i2c-dev módulos do kernel. Fazer isso na distribuição Raspbian pode ser mais ou menos assim:

  ### Instala os pacotes ~ $ sudo apt-get install python-smbus ~ $ sudo apt-get install i2c-tools ### Carrega os módulos do kernel ~ $ sudo modprobe i2c-bcm2708 ~ $ sudo modprobe i2c-dev ### Certifique-se de que os módulos carreguem na inicialização ~ $ echo "i2c-bcm2708i2c-dev" | sudo tee -a / etc / modules  

Conectar o MOD-1016 ao RaspberryPi é relativamente simples. Com o I2C, você só precisa de dois fios (SDA e SCL) - além da alimentação e do aterramento, é claro - para se comunicar com vários dispositivos. O AS3935 emite interrupções para alertar o microcontrolador sobre eventos, portanto, precisaremos de um fio adicional para isso. Usei uma placa de ensaio padrão e um RaspberryPi Cobbler da Adafruit para fazer o mock-up do circuito. O MOD-1016 (AS3935) se conecta ao RaspberryPi como tal:

MOD-1016	RaspberryPi
GND	Terrestre
VCC	3,3 V (pino 1)
IRQ	GPIO 17 (pino 11)
SCL	SCL (pino 5)
SDA	SDA (pino 3)

Uma coisa a se notar sobre o I2C é que ele foi projetado para comunicação entre chips, geralmente entre circuitos integrados encontrados no mesmo PCB. Em I2C, as linhas são mantidas altas por resistores pull-up e puxadas para baixo para indicar o estado oposto. O tempo que leva para trazer a linha de volta para VCC varia dependendo do valor do resistor pull-up e da capacitância do barramento. A especificação I2C limita a capacitância máxima a 400pF, o que normalmente restringe a distância prática a alguns metros. Existem maneiras de estender o comprimento máximo, se necessário. O mais óbvio é um extensor de barramento I2C. Diminuir a velocidade do clock também pode ajudar a aumentar a distância máxima. Além disso, esteja ciente de que, se estiver usando um cabo de par trançado como CAT-5 para conexões I2C, não execute as linhas SCL e SDA juntas no mesmo par trançado. Use pares separados e amarre a outra linha em cada par ao aterramento.

As imagens abaixo mostram o MOD-1016 breakout com um sensor de pressão barométrica MS5611 da Embedded Adventures e um amigo FTDI da Adafruit.

Assim que tudo estiver conectado, você pode usar o comando i2cdetect para ver se I2C está funcionando e pode se comunicar com o sensor. Se estiver usando um RaspberryPi mais antigo (com 256 MB de ram), você executará o comando conforme mostrado abaixo com um ID de barramento I2C de 0. Se estiver usando um RaspberryPi mais novo, use 1 em vez disso. Na saída abaixo você pode ver que o AS3935 (0x03) e o MS5611 (0x76) foram detectados corretamente.

  ~ $ sudo i2cdetect -y 0 0 1 2 3 4 5 6 7 8 9 abcde f00:03 - - - - - - - - - - - - - -10:- - - - - - - - - - - - - - - - - - 20:- - - - - - - - - - - - - - - - - --30:- - - - - - - - - - - - - - - - - --40:- - - - - - - - - - - - - - - - - - 50:- - - - - - - - - - - - - - - - - --60:- - - - - - - - - - - - - - - - - --70:- - - - - - 76 -  

Agora, para realmente usar o sensor, precisaremos ser capazes de interagir com ele. Isso é feito lendo e gravando nos registros do chip. Registradores são locais de memória usados ​​para armazenar bits para coisas como configuração e entrada / saída. De certa forma, eles são como chaves DIP digitais, onde bits ou séries de bits são usados ​​para indicar ou definir vários estados. Por exemplo, com o AS3935 é possível limpar as estatísticas construídas pelo algoritmo alternando o 7º bit (bit 6) do 3º registro (0x02). Tabelas e mapeamentos que descrevem os locais de registro e a funcionalidade podem ser encontrados na folha de dados de um dispositivo. Por exemplo,

A maioria das linguagens e plataformas possui ferramentas ou bibliotecas disponíveis para trabalhar com I2C. No Linux, por exemplo, as i2c-tools pacote fornece utilitários como i2cdetect, i2cget, i2cdump e i2cset que pode ser usado na linha de comando. Para python, o módulo SMBus fornecido pelo python-smbus O pacote oferece as ligações necessárias para acessar o barramento I2C. Muitas vezes, porém, existem bibliotecas de nível superior disponíveis para dispositivos que abstraem os detalhes de trabalhar com registros individuais. Em vez de saber quais bits ler ou gravar em quais registradores, você pode apenas instanciar uma classe e chamar métodos para interagir com o dispositivo específico.

Para trabalhar com o AS3935 em python, a biblioteca RaspberryPi-AS3935 escrita por Phil Fenstermacher está disponível. As instruções de instalação podem ser encontradas na página GitHub. Ele fornece métodos úteis, bem como um bom script de demonstração para colocá-lo em funcionamento. Para ver os métodos disponíveis e seus argumentos, dê uma olhada no arquivo RPi_AS3935.py.

O AS3935 usa um circuito RLC paralelo como antena e precisa ser ajustado para uma frequência de ressonância de 500 kHz ± 3,5%. Para compensar as variações, há até 120pF disponíveis internamente por meio de capacitores de sintonia que podem ser ativados em etapas de 8pF. Por meio de uma configuração de registro, o AS3935 pode emitir a frequência ressonante no pino IRQ, permitindo que um dispositivo externo meça e sintonize a antena apropriadamente, ativando os capacitores de sintonia necessários. Felizmente, o MOD-1016 breakouts da Embedded Adventures vem com o valor do capacitor de ajuste exibido na parte externa da bolsa antiestática. Isso torna a rotina de calibração muito mais simples. Ao usar a biblioteca acima, é tão simples quanto chamar o calibrate () método e passando o valor do capacitor de ajuste como um argumento. Mais detalhes sobre o design da antena podem ser encontrados no AS3935 AMS Hardware Design Guide.



Para obter mais detalhes:Detectando raios com um Raspberry Pi