Documentação Callisto Linux!

Visão Geral

O espectrômetro Callisto <http://e-callisto.org> é um receptor heteródino de baixo custo, desenvolvido na ETH Zurich em 2006 comvistas ao estudo da atividade solar na frequência de 60 - 860 MHz.

Callisto pode ser acoplado a uma unidade de calibração, com relays controlados por um arduino uno.

A introdução de osciladores pode fazer com que a frequência original de operação do Callisto seja alterada. Para o radiotelescópio BINGO um oscilador LO 1760MHz foi utilizado para obter uma saída IF = LO - RF na faixa de 900 a 1700 MHz.

Callisto vem equipado com um programa para o controle do espectrômetro e um programa para controle da unidade de calibração, ambos na forma de binários para windows.

O programa de controle do espectrômetro tem uma versão para sistemas Linux, em particular um pacote deb para instalação em instalações da família Debian/Ubuntu/Raspian.

Este pacote fornece operações em uma camada de controle deste binário juntamente com a agregação de controles para a unidade de calibração.

O espectrômetro callisto se conecta a um computador controlador pela USB.

A unidade de calibração é controlada por um arduino que se conecta com um computador controlador pela porta serial ou por meio de um adaptador serial/USB.

O binário callisto controla o espectrômetro e interage via protocolo TCP.

O programa callisto.py controla o binário callisto e a unidade de calibração, por meio dos protocolos serial e tcp.

Um serviço systemd callisto.service e trabalhos do crontab automatizam as operações destes dois programas e sua sinergia.

O diagrama geral das relações entre os sistemas é conforme indicado na figura:

Instalação

Verifique previamente os endereços das portas USB do callisto e da unidade de calibração. Em sistemas Linux, usualmente, o arduino se reportará como uma porta /dev/ttyACM? e a porta USB do callisto deve ser /dev/ttyUSB?. Os padrões dos arquivos de configuração são para as portas com número 0. Se necessário, altere em todos os arquivos de configuração callisto_MODE.cfg o valor correto para o dispositivo.

É recomendável verificar linha por linha o script de instalação e executar as operações individualmente. Se você estiver superconfiante, faça sudo ./install.sh, mas você foi avisado.

$ git clone https://github.com/lbarosi/callisto.git
$ cd callisto
$ sudo python -m pip install -r requirements.txt
$ # sudo ./install.sh

Uso em linha de comando

Calibração em todos os modos (COLD, WARM, HOT), com gravação de spectral overview e de arquivo FIT para cada modo:

$ python callisto.py

Parada de qualquer serviço ou programa callisto em funcionamento com cancelamento de gravação de arquivos em andamento:

$ python callisto.py --action stop
$ python callisto.py -a stop

Iniciando servico systemd:

$ python callisto.py --action start-service
$ python callisto.py -a start-service

Fazendo uma medição spectral overview:

$ python callisto.py --action overview --mode HOT
$ python callisto.py -a overview -m WARM

Fazendo uma medição FIT:

$ python callisto.py --action start --mode SKY
$ python callisto.py -a start -m COLD

Uso

Crie uma instância de Unidade de Calibraração e uma instância de Callisto para operar, passando a informação da unidade de calibração para a classe callisto.

import callisto
cal_unit = callisto.CalibrationUnit(tty="/dev/ttyACM0")
Callisto = callisto.Callisto(cal_unit=cal_unit)

Fazendo um Spectral Overview:

Callisto.record_ovs("COLD")

Medição manual FIT:
Os parâmetros para a medida em um arquivo FIT são definidos no arquivo de configuração que estiver carregado junto ao binário callisto. Tipicamente, a medição durará 15 minutos e será realizada em acordo com o arquivo de frequências padrão. Se nada foi alterado, isto significa que serão realizadas medidas em 400 canais, 2 vezes por segundo. Veja a documentação do espectrômetro callisto para mais detalhes.

Callisto.record_fits("SKY")

Vizualização rápida dos dados:

OVS

import pandas as pd
import matplotlib.pyplot as plt
path = "/opt/callisto/Ovs/NOMEDOARQUIVO.prn"
df = pd.read_table(path, sep=".")
df.columns = ["Frequency[MHz]", "S[mV]"]
LO = 1760 #oscilador local para BINGO
df["Frequency[MHz]"] = LO - df["Frequency[MHz]"]

fig, ax = plt.subplots(figsize = (16,6))
df.plot("Frequency[MHz]", "S[mV]", ax = ax)
plt.show();

FIT

import pandas as pd
from astropy.io import fits
path = "/opt/callisto/data/NOMEDOARQUIVO.fit"
hdul = fits_open(path)
df = pd.DataFrame(hdul)
fig, ax = plt.subplots(figsize = (16,6))
plt.imshow(df)
plt.show();

Documentação do Módulo

Pacote de controle do espectrômetro Callisto e de sua unidade de calibração em sistemas tipo Linux. Depende do binário callisto da distribuição Linux e utiliza conexão TCP e conexão serial.

@Author: Luciano Barosi @Date: 15.04.2022 @Links: https://github.com/lbarosi/callisto

class callisto.CalibrationUnit(tty: str = '/dev/ttyACM0', baudrate: int = 9600, bytesize=8, parity='N', stopbits=1, timeout: int = 1, version: str = 'Version: ETHZ Arduino_PrototypeV85.ino; 2016-08-17/cm')

Controla o arduino da unidade de calibração do callisto via porta serial. Os parâmetros são muito customizáveis.

Parâmetros

tty (str) – dispositivo serial do sistema. Defaults to «/dev/ttyACM0».
baudrate (int) – Defaults to 9600.
bytesize (type) – Defaults to serial.EIGHTBITS.
parity (type) – Defaults to serial.PARITY_NONE.
stopbits (type) – Defaults to serial.STOPBITS_ONE.
timeout (int) – tempo de resposta do arduino. Defaults to 1.
version (str) – string que representa versã do arduino para verificar se programa esta falando com arduino correro. Defaults to I_AM_ARDUINO.

check(): Verifica se dispositivo responde a informação de sua versão corretamente.

connect(): Inicia conexão serial.

listen(): Ouve resposta da porta serial.

send_command(command): Envia comando para a porta serial e acompanha sua execução e código de resposta.

set_relay(mode): Define estado do relay SKY|COLD|WARM|HOT

class callisto.Callisto(IP: Optional[str] = None, PORT: int = 6789, fits_command: str = 'start', ovs_command: str = 'overview', stop_command: str = 'stop', quit_command: str = 'quit', daemon: str = 'callisto.service', executable: str = 'callisto', cal_unit: Optional[str] = None)

Representa um objeto Callisto espéctrôpmetro e implementa todos os métodos necessários para garantir sua operação.

Parâmetros

IP (str) – Endereço IP da máquina conectada ao Callisto. Defaults to None.
PORT (int) – Número da PORT para conexão TCP. Defaults to 6789.
fits_command (str) – descrição do comando utilizado pelo binário calllisto para modo de medida FIT. Defaults to «start».
ovs_command (str) – descrição do comando utilizado pelo binário para realizar medida em modo overview. Defaults to «overview».
stop_command (str) – descrição do comando utilizado pelo binário para parar a observação. Defaults to «stop».
quit_command (str) – descrição do comando utilizado pelo binário para desconectar da porta TCP. Defaults to «quit».
daemon (str) – nome do serviço systemd. Defaults to «callisto.service».
executable (str) – nome do binário controlador. Defaults to «callisto».
cal_unit (CalibrationUnit) – objeto callisto.CallibrationUnit representando a unidade de calibração e os métodos necessários para operá-la. Defaults to None.

_calibrate(mode: str)

Método privado realiza operações necessárias para calibração para cada módulo separadamente.

Inicia binário, carrega configurações do modo, faz observação em modo overview e observação em modo FIT.

Parâmetros: mode (str) – (SKY|COLD|WARM|HOT).

calibrate(timeout=1)

Realiza calibração completa com os modos de operação COLD, WARM e HOT, salvando PRN e FIT nos diretórios especificados nos atributos da classe.

Ao terminar a calibração inicia o daemon de sistema.

connect(timeout: float = 2) → socket

Cria socket para conexão TCP com o binário callisto.

Parâmetros: timeout (float) – tempo padrão para aguardar resposta, em segundos. Defaults to 2.
Retorno: Socket para comunicação aberto.
Tipo de retorno: socket.socket

do(command: Optional[str] = None)

Envia comando via TCP para o binário callisto se este estiver rodando.

Seve ser utilizado após o comando run que de fato inicia o binário e carrega arquivo de configuração apropriado.

Parâmetros: command (str) – comando TCP a ser enviado. Opções válidas: (start|stop|quit|overview).

get_PID()

Determina o número dos processos callisto rodando na máquina local, emulando o comportamento de ps aux |grep callisto.

Retorno: lista contendo números dos procesos ou lista vazia se nenhum processo encontrado.
Tipo de retorno: list

get_ip(): Obtem IP da máquina local ao tentar realizar uma conexão com socket. Se resultado não é bem sucedido retorna o IP padrão do localhost 127.0.0.1.

is_running(timeout: float = 5)

Cria loop bloqueando execução enquanto callisto estiver rodando.

Parâmetros: timeout (float) – tempo máximo em secundos para aguardar execução do programa. Defaults to 5.

record_fits(mode, time=1200)

Realiza medida manual única, tipo FIT no modo especificado e vigia sistema de arquivos para verificar sucesso.

Parâmetros

mode (str) – modo válido para os relays da unidade calibradora (SKY|COLD|WARM|HOT).
time (float) – tempo para esperar a criação de um arquivo PRN no caminho padrão da classe. Defaults to 1200.

record_ovs(mode: str, time: float = 180)

Realiza medida manual única, tipo spectral overview no modo especificado e vigia sistema de arquivos para verificar sucesso.

Parâmetros

mode (str) – modo válido para os relays da unidade calibradora (SKY|COLD|WARM|HOT).
time (float) – tempo para esperar a criação de um arquivo PRN no caminho padrão da classe. Defaults to 180.

run(mode: str)

Operação manual do espectrômetro callisto no modo epecificado no argumento.

Para qualquer processo que estiver rodando, inicia novo processo com arquivo de configuração adequado ao modo (SKY|COLD|WARM|HOT) mas não executa nenhuma ação adicional, deixando sistema pronto para iniciar medida.

Utiliza função run_command para executyar comando shell e retorna STDOUT, STDERR.

run_daemon(manager: str = 'sudo /bin/systemctl', action: str = 'start')

Roda o serviço systemd com a ação especificada no argument.

A execução do programa é realizada em thread separada e colocada em background, sobrevivendo a execução do script.

Parâmetros

manager (str) – caminho completo to controlador do daemon. Defaults to «sudo /bin/systemctl».
action (str) – Ação a ser executada, dentre as opções disponíveis em processos daemon: (start|stop|reload). Defaults to «start».

stop(): Para o daemon callisto se este estiver rodando e envia SIGTERM para todas as instâncias do binário que estiverem rodando. Funciona apenas se regras sudoer adequadas tiverem sido implementadas para o comando sudo pkill callisto.

class callisto.Handler(pattern: Optional[str] = None)

Implementa o gerenciador de eventos de arquivos utilizado em conjunto com o file watchdog.

Para o módulo callisto só é necessário implementar o método que lida com a criação de arquivos, encarregada de acompanhar a execução das operações do binário callisto e permitir a verificação do sucesso das operações.

Parâmetros: pattern (str) – máscara para observar os arquivos pattern. Padrão é None.

created

determina se arquivo satisfazendo a máscara foi ou não criado.

Type: bool

on_created(event)

Chamada quando um arquivo satisfazendo a máscara é criado.

Parâmetros: event (DirCreatedEvent or FileCreatedEvent) – Evento representando a criação de arquivo ou diretório.

class callisto.WatchFolder(path: Optional[str] = None, recursive: bool = False, pattern: Optional[str] = None, timeout: Optional[float] = None)

Monitoramento contínuo de eventos de arquivos e diretórios baseado no pacote watchdog.

Parâmetros

path (str) – caminho completo onde observar os arquivos. Defaults to None.
recursive (bool) – Defaults to False.
pattern (str) – máscara para vigiar arquivos. Defaults to None.
timeout (float) – timeout em segundos para manter vigiando o caminho indicado. Defaults to None.

observer

observer.

Type: watchdog.observers

run()

Inicia observação do caminho indicado.

Vigia a alteração (criação, modificação, deleção de arquivos ou diretórios) e manipula conforme o handler o evento que ocorreu.

callisto.main(): Roda programa principal do módulo.

callisto.run_command(command: str) → tuple[str, str]

Executa comando shell passado como argumento utilizando biblioteca subprocess.

Função reporta erro no arquivo de log se houver algum erro que não represente a informação do binário callisto de que não detectou o arquivo scheduler, uma vez que este não é um erro e apenas uma informação do status desejado.

Parâmetros: command (str) – string de comando escrita da mesma forma que se escreveria em linha de comando.
Retorno: saída padrão e código de erro informado para o comando executado.
Tipo de retorno: tuple[str, str]

callisto.run_detached(command: str) → Process

Roda o comando indicado em modo background, liberando a execução do resto do programa.

Parâmetros: command (str) – string de comando escrita da mesma forma que se escreveria em linha de comando.
Retorno: processo em execução.
Tipo de retorno: multiprocessing.Process

Diagrama de Relações Entre Métodos e Classes

Documentação Callisto Linux!

Visão Geral

Instalação

Uso em linha de comando

Uso

Documentação do Módulo

Diagrama de Relações Entre Métodos e Classes

Descrição dos Arquivos

Indices and tables