Conhecimento
Medidas Automáticas com DM858 e Python
A automatização da aquisição de medidas é uma estratégia fundamental para a pesquisa e desenvolvimento ou para a análise de qualidade industrial, em especial quando as medidas a serem realizadas são repetitivas ou complexas. A programação das medições permitem a obtenção de resultados de forma rápida e eficiente, possibilitando a realização de medidas contínuas, de longa duração ou com diferentes condições, evitando, por vezes, erros decorrentes da ação humana. Com processos de medidas automatizados, é possível coletar dados consistentes e de fácil análise em tempo real. Pensando nisso, escrevemos esse artigo, no qual explicamos como implementar SCPI em python para que dessa forma, você possa automatizar processos de aquisição de medidas.
O protocolo SCPI
Antes de realizar a programação efetivamente, é importante conhecermos as ferramentas que usaremos, isto é, o protocolo SCPI (Standard commands for programable instruments). Esse protocolo, como o nome já diz, consiste em comandos de texto padronizados que permitem o controle de dispositivos como fontes, multímetros, osciloscópios, entre outros, usando um computador conectado à mesma rede. Nessa padronização, temos palavras chaves que definem o que será feito pelo instrumento. Essas palavras são organizadas de forma hierárquica, então, os comandos usados dever seguir sempre uma mesma estrutura.
Um exemplo de comando em SCPI seria “MEASure:VOLTage:DC? 10, 1E-3”. Aqui, temos o comando principal “MEASure”, que indica o tipo de comando que queremos executar, que nesse caso é realizar uma medida. Os comandos seguintes são para selecionar dentro das medidas possíveis qual sera realizada, que nesse caso é VOLTage:DC, ou seja, tensão em corrente continua. Em seguida temos um ponto de interrogação (?) que indica que a operação a ser realizada é uma consulta, e portando, o dispositivo enviar o resultado para o computador. Finalmente enviamos os parâmetros “10, 1E-3”, que pré configuram o multímetro para tensões no range de 10V com uma resolução de 1mV.
No comando acima temos parte da palavra em maiúsculo e parte em minúsculo, mas isso é apenas para indicar qual parte do comando é obrigatório para o DM858 compreender, sendo que o comando será entendido se for enviado na sua forma completa, ou omitindo a parte minúscula. Além disso, o protocolo SCPI não é case sensitive, isto é, ele não diferencia letras maiúsculas das minúsculas. Assim, esse mesmo comando pode ser escrito como “meas:volt:dc? 10, 1e-3” ou como “MEAS:VOLT:DC? 10, 1E-3” ou qualquer combinação de maiúsculas e minúsculas, que ele funcionará normalmente. O manual completo de comandos SCPI do DM858 pode ser encontrado aqui.
Configurações inicias
Agora que já estamos familiarizados com o SCPI, podemos fazer umas configurações iniciais para a programação. O que usaremos para a interface de comunicação sera o VISA (Virtual instrument software architecture), que de forma simplificada é um conjunto de ferramentas que facilita a comunicação entre o computador e o instrumento de medição. Ele fornece uma camada de abstração, permitindo que o software controle o instrumento sem precisar lidar diretamente com os detalhes da interface física. O interessante do VISA é que ele não depende do tipo de interface realizada, e portanto pode ser usado quando o instrumento esta ligado por meio de Ethernet, USB, RS232, etc.
Então, para conseguirmos usar o VISA, precisamos instalar a biblioteca pyvisa, que pode ser obtida com o comando “pip install pyvisa-py”. Caso você não possua o pip em sua máquina, você pode encontrar o manual de instalação clicando aqui. Outras bibliotecas que usamos são as bibliotecas matplotlib para a geração de gráficos, que você pode instalar usando “pip install matplotlib”. A biblioteca pandas, para gestão arquivos do tipo .CSV, também foi usada, e você pode obtê-la usando “pip install pandas”.
Com essas instalações feitas, precisamos ainda conectar o multímetro DM858 a rede ethernet, e encontrar o endereço VISA, do multímetro. Isso é simples, para isso, basta realizar a conexão do cabo ethernet na parte de trás do multímetro e no roteador, que a conexão está pronta. Agora, no multímetro, tocamos no “R”, em seguida abrimos o menu “Sistema”, e selecionamos a aba “Rede”, então encontraremos o endereço VISA do seu instrumento. Anotamos esse endereço pois usaremos ele mais adiante.
Programando
Finalmente vamos para o código usado no nosso projeto, que começa importando as bibliotecas que instalamos anteriormente, além da biblioteca “time”, que foi usada para realizar delays e gravar o tempo entre as medidas.
import pyvisa as visa
import pandas as pd
import matplotlib.pyplot as plt
import time
# Define quantidade de medidas e intervalo entre elas
num_medidas = 30
intervalo = 5
# Cria as listas para armazenar as medidas e o intervalo de tempo
momento = [ ]
temperatura = [ ]
Em seguida, definimos o número de medidas e o intervalo entre as medidas, iniciando as variáveis ”momento” e “temperatura” logo após. Essas variáveis serão usadas para gravar o instante em que a medida foi realizada e a temperatura encontrada respectivamente.
O próximo passo foi criar uma instância para o gerenciamento da comunicação entre o instrumento e o computador, abrindo o “multímetro”, usando o método “open_resource(“Endereço visa”)”. Para este método que enviamos o endereço visa anotado anteriormente. Por fim configuramos a terminação da comunicação, tanto para leitura, quanto para a escrita.
# Configura a comunicacao com o multimetro
rm = visa.ResourceManager()
rm.list_resources()
multimetro = rm.open_resource("TCPIP::192.168.1.93::INSTR")
multimetro.read_termination = '\n'
multimetro.write_termination = '\n'Na etapa seguinte, realizamos as medidas. Aqui configuramos a unidade de temperatura do multímetro para graus celsius e realizamos as medidas em um loop, que no nosso caso é repetido 20 vezes, com uma vez a cada 5 segundos. Essas quantidades podem ser ajustadas, alterando-se os valores das grandezas “num_medidas” e “intervalo”. Isso ficou como abaixo.
# Realiza as medidas
start_time = time.time()
multimetro.write("UNIT:TEMP C")
for i in range(num_medidas):
momento.append(time.time() - start_time)
temperatura.append(float(multimetro.query("MEAS:TEMP? TC, K")))
time.sleep(intervalo)
rm.close()
Dentro do loop acima, adicionamos o instante e a leitura no final das listas “momento” e “temperatura”, em seguida, adicionamos uma pausa, antes de realizar a próxima medida. Aqui é importante notar os métodos .write e .query que foram usados. Começando pelo comando .write, temos que ele envia um comando em SCPI para o multímetro, sendo que ele deve ser usado para enviar comandos de configuração. Enquanto isso, o método .query envia comandos e realiza a leitura da resposta do multímetro, por isso usamos ele para enviar o comando “MEAS:TEMP? TC, K”, que realiza a leitura de um termopar tipo k.
Finalmente vamos para as saídas do nosso programa, que são um arquivo .CSV, resultado do pandas, e um gráfico, advindo da biblioteca matplotlib.
# Salva as medidas em um arquivo CSV
log = pd.DataFrame(data={"momento": momento, "temperatura": temperatura})
log.to_csv("leituras.csv", index=False, sep=",",decimal=",")
# Plota o grafico
fig, ax = plt.subplots(figsize=(10, 5))
ax.set_title("Temperatura x Tempo")
ax.set_xlabel("Tempo")
ax.set_ylabel("Temperatura")
ax.plot(momento, temperatura, color = "red", marker = "o", markerfacecolor = "white", markersize = 5)
ax.xaxis.set_major_locator(plt.MaxNLocator(nbins=7, prune='both'))
plt.tight_layout()
plt.show()Testando
Agora que já fizemos a nossa programação, podemos ver o nosso código funcionando na prática. Para isso, fizemos uma montagem bastante simples, apenas para ilustrar o funcionamento do código. Essa montagem consiste apenas ao termopar preso junto a ponta de um ferro de solda com o auxilio de uma fita kapton, assim, conseguimos medir a temperatura desse equipamento. Usando essa montagem fizemos o gráfico abaixo.
Nesse gráfico, ligamos o ferro de solda ao mesmo tempo em que executamos o programa escrito. As marcações presentes neste gráfico são as medidas que realmente realizamos, isto é, os valores das variáveis momento, representados na horizontal, e temperatura, na vertical. O formato e a cor desses marcadores, além da cor da linha foram definidos na linha “ax.plot(momento, temperatura, color = “red”, marker = “o”, markerfacecolor = “white”, markersize = 5)”. Os valores plotados nesse gráfico estão no arquivo .CSV gerados pela biblioteca “pandas”, assim você pode usa-lo em um outro software de sua preferencia. Para acessar o arquivo .CSV, precisamos tomar cuidado com os separadores de casas decimais e de células do arquivo.
Neste artigo discutimos um pouco sobre como usar o protocolo SCPI para controlar instrumentos de bancada, realizando uma pequena automação com o Python. Essa automação é simples, mas ela já serve para demonstrar um caminho para a automação de medidas mais sofisticadas.
Se você esta buscando instrumentos que podem ser usados para as suas medições, a Ryndack Componentes, distribuidora oficial da Rigol, conta com diversos equipamentos como multímetros, osciloscópios e fontes de alimentação.
Autor
Willian Mateus Ferreira dos Santos
Graduando em engenharia elétrica pela UFPR, onde começou seu relacionamento de amor e ódio com a eletrônica. Hoje atua no setor técnico da Ryndack Componentes, buscando aprofundar seus conhecimentos sobre eletrônica.
