ROBUSTA

ENGENHARIA

RELATRIO DE ATIVIDADES 27/10/2015

RHAE Comunicao Serial entre atuador-RaspberryPi com Servidor. Threads.
Ms de Referncia - Outubro de 2015
Jos Alberto Pereira dos Santos.
1. Discorra sobre as principais atividades desenvolvidas no perodo:
a)
b)
c)
d)
e)
f)
g)
h)
i)
j)
k)
l)
m)

Estudo Raspberry Pi;

Memria e Sistema Operacional;
GPIOs;
Comunicao;
Rs 485, Modbus;
Elaborao Manual medidor KRON;
Montagem de quadro para medio do sistema fotovoltaico.
Elaborao de Sistema de monitoramento em Labview.
Elaborao de Sistema de monitoramento em Python.
Utilizao de Threads no Projeto.
Utilizao do WebServer no Projeto.
Transmisso dos dados.
Adaptao do cdigo.

2. Apresentao e discusso sucinta dos principais resultados do perodo:

a) Estudo Raspberry Pi.
Comeamos com um estudo sobre o Raspberry Pi, suas ferramentas e
acessrios,

necessrio

para

conseguirmos

utiliza

lo.

Raspberry

um

microcomputador que oferece vantagens pela sua relao entre tamanho e

processamento e tambm pelo seu preo.

Pgina 1 de 38

ROBUSTA
ENGENHARIA

Figura 1 Raspberry Pi modelo B

b) Memria e Sistema Operacional.

O Raspberry Pi no possui um HD como os computadores convencionais, ao
invs disso ele usa um carto microSD como HD, este carto deve ser previamente
preparado para que possamos inserir o nosso sistema operacional nele e ento
configurar o nosso Raspberry.
Para prepararmos o nosso carto foi necessrio a utilizao de um software, o
SDFormatter,

ele

gratuito

pode

ser

obtido

no

link

https://www.sdcard.org/downloads/formatter_4/ ). Aps o download e instalao do

software, conectamos o nosso carto de memria ao computador atravs de um leitor
de microSD e ento executamos o SDFormatter, selecionamos o nosso dispositivo na
aba drive, depois de selecionar o nosso dispositivo, configuramos a sua formatao
Pgina 2 de 38

ROBUSTA
ENGENHARIA
clicando em option e selecionando as opes FORMAT TYPE : QUICK e
FORMAT SIZE ADJUSTEMENT : ON , ento clicamos em format.
Com o carto formatado, precisamos realizar o download dos arquivos do S.O.
( Sistema Operacinal ) que tambm gratuito e pode ser obtido no link
( https://www.raspberrypi.org/downloads/ ), como o arquivo baixado estava em um
formato compacto foi necessrio primeiro extrair os arquivos para ento copia los
para o carto microSD. Feito isso nosso carto estava pronto e poderia ser usado no
nosso Raspberry. Uma observao importante que o carto usado precisa ter no
mnimo 8Gb de memria e aconselhadamente ser da classe 10.
Com o carto j pronto e plugado no nosso Raspberry, podemos liga lo para ento
configurarmos o nosso SO. Para isso foi necessrio uma fonte de alimentao
microUSB de 5V DC com capacidade de corrente de at 2A, um mouse, um teclado e
um monitor com entrada HDMI. Tendo conectado primeiro todos os acessrios, ento
ligamos o Raspberry e ele nos apresentou a sua tela inicial de instalao de sistema
operacional, como queremos trabalhar com o Raspbian ele foi selecionado. Como
mostra a figura a seguir:

Pgina 3 de 38

ROBUSTA
ENGENHARIA

Figura 2 Tela inicial.

Pgina 4 de 38

ROBUSTA
ENGENHARIA
Quando selecionamos o nosso SO e prosseguimos com a instalao o Raspberry
terminou a instalao e deu reboot j voltando com no SO Raspbian como mostra a
figura a seguir:

Figura 3 Desktop Raspbian.

Pgina 5 de 38

ROBUSTA
ENGENHARIA
c) GPIOs.
O Raspberry possui sadas GPIOs que so melhores representadas na imagem
abaixo:

Figura 4 GPIOs

Para testarmos algumas portas foi implementado um cdigo em Python por j ser
uma linguagem compatvel com o Raspberry. O cdigo teve como objetivo testar
umas das portas GPIO, para realizar o teste foi escolhido um exemplo o BLINK, que
no faz nada mais que piscar um led que est conectado a porta, abaixo segue o
cdigo que foi implementado e o circuito que foi montado.
1.

import RPi.GPIO as GPIO

//Importa a biblioteca das GPIO

2.

import time

//Importa a biblioteca de tempo

3.

GPIO.setmode(GPIO.BOARD)

//Configura o modo de definio

de pinos como BOARD (contagem de pinos da placa)

Pgina 6 de 38

ROBUSTA
ENGENHARIA
4.

GPIO.setup(18, GPIO.OUT)

//Configura o pino 18 da placa

(GPIO24) como sada

5.
6.

while(1):

//Inicia o loop infinito

print("LED ACESO\n")

//Escreve na Python Shell a

mensagem "LED ACESO" e pula uma linha

7.

GPIO.output(18, 1)

//Coloca o pino 18 em nvel

8.

time.sleep(1)

//Delay de 1 segundo

9.

print("LED APAGADO\n")

alto

//Escreve na Python Shell a

mensagem "LED APAGADO" e pula uma linha

10.

GPIO.output(18, 0)

//Coloca o pino 18 em nvel

baixo (0)
11.

time.sleep(1)

//Delay de 1 segundo

Cdigo Python.

Figura 5 Circuito.

Pgina 7 de 38

ROBUSTA
ENGENHARIA
d) Comunicao.
Para testarmos a nossa comunicao serial do Raspberry Pi, montamos uma
comunicao simples entre um arduino e o Raspberry Pi.
O primeiro passo foi abrir o terminal do Raspberry e atualizar a biblioteca de
comunicao serial, digitando o seguinte cdigo:

sudo apt-get install python-serial

Pgina 8 de 38

ROBUSTA
ENGENHARIA

Assim o Raspberry ir atualizou a biblioteca, aps a atualizao comeamos o

desenvolvimento do cdigo em Python para uma comunicao simples, o objetivo do
cdigo ser fazer com que o arduino controle um led que estar conectado em uma
das suas portas atravs de um boto que estar ligado em outra porta do mesmo,
ento o arduino ir enviar qual o estado do led para o Raspberry Pi, e o Raspberry Pi
tambm ira controlar o Led enviando um comando para o arduino, ( 1 ou 0 ).
A seguir temos o cdigo comentado do Arduino:

Pgina 9 de 38

ROBUSTA
ENGENHARIA

boto

1.

const int buttonPin = 2;

// porta do boto

2.

const int ledPin = 13;

// porta do LED

3.

// variaveis para realizar o debaunce

4.

int ledState = HIGH;

// estado atual do LED

5.

int buttonState;

// estado do boto

6.

int lastButtonState = LOW;

7.
char leitura;
estado do LED

// ultima leitura do estado do

pino

// variavel auxiliar para guardar o

8.

int c1 = 0;

// contador auxiliar

9.

int c2 = 0;

// contador auxiliar

10.

long lastDebounceTime = 0;

11.

long debounceDelay = 50;

12.

void setup() {

13.

pinMode(buttonPin, INPUT); // definindo pino de entrada

14.

pinMode(ledPin, OUTPUT);

// definindo pino de saida

15.

Serial.begin(9600);

// inicializando serial

16.

digitalWrite(ledPin, ledState);

17.

18.

void loop() {

// ultima mudana que ocorreu no

// tempo de duracao do debounce

// setando estado inicial do

LED

19.

int reading = digitalRead(buttonPin); // le o estado do boto

20.
de estado.

if (reading != lastButtonState) { // verifica se o botao mudou

21.

lastDebounceTime = millis();

22.

// reseta o tempo do debounce

23.
if ((millis() - lastDebounceTime) > debounceDelay) { // quando
passa o tempo do debounce
24.
if (reading != buttonState) {
diferente do valor atual do botao
25.

buttonState = reading; // entao o botao recebe o novo valor

26.
27.

if (buttonState == HIGH) {
ledState = !ledState;

28.
pela serial

// quando o botao precionado

// invertemos o estado do led

Serial.println(ledState);

29.

// enviamos o estado do led

30.
31.

// se o valor lido

}
}

32.
33.
raspberry
34.

leitura = Serial.read();

// le a informacao mandada pelo

if ((leitura == '1')&&(c1 == 0)) { // verifica se uma leitura

Pgina 10 de 38

ROBUSTA
ENGENHARIA
nova
35.

ledState = HIGH;

// altera o valor do LED

36.
c1 = 1;
realizar a tarefa de novo

// seta o contador pra nao

37.
c2 = 0;
proxima mudana

boto

// zera o contador2 para a

38.

Serial.println(ledState);

39.

40.

if ((leitura == '0')&&(c2 == 0)){ //idem o anterior

41.

ledState = LOW;

42.

c1 = 0;

43.

c2 = 1;

44.

Serial.println(ledState);

45.

46.

digitalWrite(ledPin, ledState);

47.
48.

// seta o valor do LED:

lastButtonState = reading;

// Salva o ultimo estado do

Pgina 11 de 38

ROBUSTA
ENGENHARIA

A seguir temos o cdigo desenvolvido em Python para o Raspberry Pi:

Pgina 12 de 38

ROBUSTA
ENGENHARIA
1. import serial # importando biblioteca de comunicacao serial
2. import time

# biblioteca time para usar os delays

3. ser = serial.Serial('/dev/ttyAMA0', 9600, timeout=1) # configurando

Serial.
4. ser.open() # iniciando comunicacao
5. try:
6.

tecla

while 1: # iniciando loop

7.

ser.write("1")

# manda o caractere 1 pela serial

8.

time.sleep(2)

# delay

9.

response = ser.readline() # le a serial

10.

print response # imprimi o valor lido

11.

ser.write("0") # manda o caractere 0 pela serial

12.

time.sleep(2) # delay

13.

response = ser.readline() # le a serial

14.

print response # imprimi o valor lido

15.

except KeyboardInterrupt: # interrupo caso aperte uma

16.

ser.close() # finaliza comunicacao

Pgina 13 de 38

ROBUSTA
ENGENHARIA

Um cuidado que necessrio ser tomado verificar a tenso de comunicao de

cada dispositivo, no nosso caso a tenso diferente visto que o arduino se comunica
com 5V e o Raspberry Pi com 3.3V para resolver este problema foi necessrio usar
um divisor de tenso na entrada de dados do Raspberry Pi para que o mesmo no
sofresse nenhum dano. A seguir temos uma ilustrao do circuito para realizar a
comunicao:

Figura 6 Circuito 2.
e) Rs 485, ModBus;
Para a leitura dos nossos dados do sistema, estaremos utilizando um
Multimedidor Trifsico Mult K da Kron instrumentos eltricos.

Pgina 14 de 38

ROBUSTA
ENGENHARIA

Figura 7 Medidor Mult K .

O medidor foi escolhido devido a facilidade de obteno do mesmo.
Ele possui uma sada Rs - 485 utilizada para comunicao entre o medidor e o
supervisrio, os dados tambm podem ser lidos no prprio medidor. Antes de tudo,
foi necessrio entender melhor o protocolo ModBus para ento continuarmos.
O Modbus um protocolo de comunicao serial, desenvolvido pela Modicon
em 1979, para ser usado em PLCs.
formado pela estrutura mestre-escravo, onde o mestre encarregado de
requisitar a informao dos escravos. Em uma rede padro Modbus, existem 247
escravos e 1 mestre. Cada escravo tem o seu endereo nico de 1 a 247.
O Modbus gratuito e aberto, por isso acabou se tornando um protocolo
padro dentro das indstrias. Geralmente ele usado para comunicao entre
supervisrio e as unidades terminais ou seja, sensores e dispositivos de controle.
Os dados so enviados por um fio e recebidos por outro de forma que as
tenses positivas representam 0 e as negativas representam 1 como mostra a figura
abaixo :

Figura 8 Tenses
O pacote de dados mostrado na figura abaixo :

Pgina 15 de 38

ROBUSTA
ENGENHARIA

O endereo o primeiro byte enviado ( de 1 a 247 ), a funo ou Function

Code o segundo byte enviado, e o que determina a ao a ser realizada pelo
escravo, leitura/escrita que tambm de 1 byte e ento os dados propriamente ditos
so transmitidos e podem conter de 0 a 252 bytes.
O CRC um mtodo de verificao de erro, ele verifica se o pacote chegou de
forma correta, ele calculado atravs de todos os bytes anteriores quando a
mensagem enviada e quando recebida, ento ambos so comparados e se no
forem iguais exibida uma mensagem de erro, para informar que o pacote no
chegou corretamente.

Pgina 16 de 38

ROBUSTA
ENGENHARIA
Depois de entender melhor o protocolo, partimos para as configuraes que
devem ser feitas no Medidor para que possamos utiliza lo. Temos a seguir um passo
a passo obtido do manual do equipamento, que explica de forma clara o que deve ser
feito para a configurao da interface serial.
1. Selecione a funo End (endereo) atravs das teclas e ;
2. Pressione modo para entrar no modo de edio do endereo;
3. A tecla modo seleciona o prximo dgito e as teclas e incrementam ou
decrementam o dgito selecionado. A faixa vlida para este parmetro de 1 at 247
(o valor 254 indica que o equipamento est sem endereo atribudo) Aps ajustar o
ltimo dgito, pressione modo para gravar o valor no multimedidor;
4. Selecione a funo bAU (baud rate velocidade) atravs das teclas e ;
5. Pressione modo para alternar entre as velocidades de 9.6, 19.2, 38.4 ou
57.6 kbps;
6. Selecione a funo StP (formato de bits) atravs das teclas e ;
7. Pressione modo para entrar no modo de seleo de paridade e stop bits;
8. Com as teclas e selecione a configurao desejada (8n1, 8n2, 8E1,
8O1) e com a tecla modo confirme sua escolha.
No nosso caso definimos o endereo como 001, o baud rate como 9.6 e a
paridade e stop bits como 8n1.
Para testarmos o funcionamento do medidor utilizamos o software fornecido
pela prpria empresa ( KRON ), o nome do programa redeMB, fornecido
gratuitamente

pela

empresa

atravs

http://www.kronweb.com.br/br/downloads_softwares.php

do
),

aps

link
o

(
download

instalao do software foi possvel realizar o teste, a seguir temos a tela inicial do
programa.

Pgina 17 de 38

ROBUSTA
ENGENHARIA

Figura 9 Tela inicial redeMB.

Como o nosso computador no possui uma sada RS 485, foi necessrio
utilizarmos um conversor RS-485 para USB. Mostrado a seguir:

Figura 10 Conversor RS-485 para USB

Aps realizarmos as conexes dos terminais do medidor e do conversor foi
possvel realizar a configurao do redeMB, que deve ser coerente com a
configurao realizada anteriormente no medidor. Para configurarmos utilizamos o
menu Sistemas, e ento comunicao, a seguinte tela deve surgir :
Pgina 18 de 38

ROBUSTA
ENGENHARIA

Figura 10 Comunicao redeMB.

No menu anterior foi possvel configurar a comunicao, depois disto temos de
cadastrar o nosso medidor atravs do menu Dispositivo, e ento Adicionar, a
aeguinte tela deve surgir:

Pgina 19 de 38

ROBUSTA
ENGENHARIA

Figura 11 Dispositivo redeMB.

O primeiro campo deve ser preenchido com o cdigo de srie que vem colado
atrs do medidor. O segundo com o endereo anteriormente selecionado ( endereo
Modbus ). E a descrio utilizada para nomear o seu dispositivo.
Aps realizarmos essas configuraes foi possvel realizar o teste do medidor
atravs no menu Dispositivo e ento Ler, a seguinte tela ir surgir:

Pgina 20 de 38

ROBUSTA
ENGENHARIA

Figura 12 Leitura redeMB.

Ento selecionamos o nosso dispositivo e teremos os nossos dados. Verificou
se que o dispositivo estava em perfeito funcionamento.
O prximo passo tomado foi montar um diagrama em Labview ( verso gratuita
de 45 dias ), para que pudssemos entender melhor o funcionamento do protocolo
ModBus e os seus pacotes de comunicao. O diagrama montado mostrado a
seguir :

Pgina 21 de 38

ROBUSTA
ENGENHARIA

Figura 13 Diagrama Labview.

Para realizar a comunicao foi utilizado a biblioteca de comunicao Modbus
do labview. Foi possvel ento realizar a comunicao com o medidor e a partir de
agora podemos comear a entender melhor como funcionam os pacotes do Modbus.
f) Elaborao manual medidor KRON.
O medidor utilizado o Mult K da Kron Instrumentos Eltricos ltda. Ele possui
maior destaque entre os demais devido ao seu custo beneficio, capaz de medir at
44 grandezas eltricas, que podem ser lidas em seu display ou transmitidas atravs
de uma comunicao serial Rs 485, utilizando o protocolo de comunicao ModBus
RTU. Possui capacidade para atender os seguintes casos: Trifsico Estrela 3F + N
3 elementos 4 fios, Bifsico 2F + N 2 elementos 3 fios, Monofsico 1F + N 1
elemento 2 fios, Trifsico Estrela Equilibrado 3F + N 1 elemento 2 fios, Trifsico
Delta 3F 3 elementos 3 fios, Trifsico Delta 3F 2 elementos 3 fios.
Para carter de teste, primeiramente iremos montar um esquema que permite
simular um sistema onde o equipamento ir realizar medidas de si mesmo. Para isso,
realizamos as seguintes ligaes:

Pgina 22 de 38

ROBUSTA
ENGENHARIA

Figura 14 Esquema de ligao.

Pgina 23 de 38

ROBUSTA
ENGENHARIA
Aps realizarmos estas ligaes, podemos realizar as conexes da
comunicao, entretanto como o nosso computador no possui uma sada para Rs
485, necessrio utilizar um conversor de Rs 485 para USB. Logo o nosso
dispositivo est instalado e pronto pra ser testado. Entretanto, primeiro vai ser
necessrio configurarmos o nosso dispositivo atravs da interface homem maquina
que o equipamento dispe.
A interface do equipamento possui: Trs linhas de 3 dgitos de LED de 7
segmentos de alto brilho, para visualizao do valor numrico das grandezas, Seis
LEDs para indicao da grandeza que est sendo apresentada no display, Trs teclas
para navegao e parametrizao do instrumento e LEDs indicativos da escala da
grandeza que est sendo apresentada.
O medidor possui trs modos de operao, o modo instantneo onde ele
mostra os valores de algumas das grandezas eltricas instantneas no display
( tenso, corrente, freqncia e etc) , o modo energia onde ele mostra os valores das
grandezas eltricas acumulativas no display ( demanda, consumo e etc) e o modo
funes onde possvel configurar o nosso equipamento. Para os fins desejados
apenas os modos: instantneo e de parametrizao sero utilizados.
Ao ligar o equipamento o mesmo j se encontra no modo instantneo. Para
podermos configura lo teremos de mudar o modo para funes, para isso, temos que
pressionar as teclas e

simultaneamente at a abreviao FUn aparecer na

primeira linha do display numrico e todos os LEDs comearem a piscar. Caso aps
soltar as teclas, aparea a mensagem SEn em L1 ( Primeira linha do display ), entre
com a senha 021 para acesso ao modo Funes. Com a tecla modo se movimente
entre os dgitos e utilize e para incrementar ou decrementar o dgito selecionado.
De forma a identificar que o instrumento est no modo Funes, os LEDs k e M
ficaro piscando durante todo o processo de parametrizao.
No modo funo ser possvel configurar os seguintes parmetros: tP
( Relao de transformador de potencial ), tC ( Relao de transformador de
corrente ), tL ( Esquema de ligao ultilizado), tI ( Intervalo de integrao para o
calculo da demanda) , PEn ( Programao de sada de pulsos), End ( Endereo
Modbus), bAU ( Baud rate), StP ( Stop bits), rSt ( Reset dados de energias, demandas
e Max tenso e corrente), CEr ( Leitura de cdigo de erro), SOF ( Leitura de verso
do software interno), Sen ( Habilitar/Desabilitar senha de acesso).

Pgina 24 de 38

ROBUSTA
ENGENHARIA
Para modificar qualquer um dos parmetros, basta selecionar o parmetro
desejado atravs das teclas e e pressionar a tecla modo, para editar a constante
ento voc editar os valores atravs das teclas e e confirmar a edio atravs da
tecla modo.
Sobre o ponto flutuante do aparelho ou seja a forma de representao de
nmeros reais utilizada na comunicao. Ela feita da seguinte maneira h um
deslocamento da vrgula de forma que se obtenha um nmero menor ou prximo de
1. Esse deslocamento feito por meio de notao cientfica. Esclarecendo: o nmero
25,456 em notao corresponde ao 0,25456 x 10 2. Ento os dados so separados da
seguinte maneira: parte fracionaria base e expoente. O pacote de dados fica da
seguinte forma : 1 bit para o sinal do numero, 1 bit para o sinal do expoente, 4 bits
para o expoente e 10 bits para a mantissa ( parte fracionaria) .
O problema que a ordem desses bits pode ser mudada, e para que
possamos ter sucesso na comunicao a ordem dos bits enviados tem que ser a
mesma da leitura, ou no iremos realizar uma leitura correta. No nosso caso a ordem
dos bits de ponto flutuante do modbus poll e do labview era diferente da ordem dos
bits do medidor da kron. Porm o medidor permite que voc altere essa ordem, logo
foi necessrio realizar a troca dessa ordem de forma a obter a leitura correta.
Para realizar a mudana, foi utilizado o modbus poll, devido a praticidade de se
realizar a mudana atravs do mesmo. Primeiro conecte o medidor ao computador e
abra o ModBus poll, clique no menu Functions e ento em test Center. A seguinte
tela dever aparecer:

Pgina 25 de 38

ROBUSTA
ENGENHARIA

Figura 15 Tela Modbus poll.

Agora poderemos alterar o ponto flutuante do medidor, para isso vamos enviar
a seguinte mensagem para o medidor:
01 06 01 2C 23 01
Onde
01 Endereo do medidor.
06 Funo do Modbus ( single register ).
01 2C Posio de memria do ponto flutuante.
23 01 Ordem dos bits ( os bits sempre sero 0,1,2 e 3 o que altera a ordem
).
Ao enviar est mensagem o medidor estar com a mesma ordem do modbus
poll e voc conseguir ler os dados do medidor de forma correta.
g) Montagem de quadro para medio do sistema fotovoltaico.

Foi realizada a montagem de um quadro para o medidor, que foi colocado junto
ao inversor de um sistema fotovoltaico, que servir para realizarmos medidas e
testarmos o medidor. Segue abaixo fotos do quadro.
Pgina 26 de 38

ROBUSTA
ENGENHARIA

Figura 16 Frontal quadro.

Pgina 27 de 38

ROBUSTA
ENGENHARIA

Figura 17 Quadro parte interna.

h) Elaborao de Sistema de monitoramento em Labview.

Para realizar o monitoramento do sistema fotovoltaico primeiramente foi
desenvolvido uma interface em Labview, para que o sistema pudesse ser monitorado
atravs de um computador. O programa em labview est dividido em :

Identificao e configurao dos parmetros da porta de comunicao.

Leitura e tratamentos dos dados.
Gerao de relatrio em arquivo de texto.
Gerao de grfico ( Potncia x Tempo ).

A seguir temos uma imagem da interface grfica do labview :

Pgina 28 de 38

ROBUSTA
ENGENHARIA

Figura 18 Interface grfica Labview.

i) Elaborao de Sistema de monitoramento em Python.

Depois de realizar o monitoramento via labview, foi feito um programa em
python para que o monitoramento pudesse ser realizado no RaspBerry Pi. O
programa no Raspberry gera um relatrio em formato de arquivo de texto.
O primeiro ponto a ser trabalhado foi a ordem dos dados do ponto flutuante,
que dividido em 32 bits, que foram obtidos atravs de dois pacotes de 16 bits, lidos
via modbus. Os 32 bits so divididos em 1 bit de sinal, 8 bits de expoente e 23 bits de
mantissa. Para realizar a leitura necessrio primeiramente ler os dois pacotes e
concatena los em apenas um array e ento realizar um tratamento que funciona da
seguinte forma:
(1)sinal(1+ Mantissa)10(expoente127)
Aps realizar o tratamento e leitura de cada um dos dados, gerado um
relatrio no formato de arquivo de texto.
A seguir temos o cdigo em python, comentado:

Pgina 29 de 38

ROBUSTA
ENGENHARIA
1. import array
2. import struct
3. import sys
4. import serial
5. import random
6. import time
7. #Sub Programa
8. #Clculo CRC modbus
9. def CRCcal(msg):
10.
CRC = 0xFFFF
11.
CRCHi = 0xFF
12.
CRCLo = 0xFF
13.
CRCLSB = 0x00
14.
for i in range(0, len(msg)-2,+1):
15.
CRC = (CRC ^ msg[i])
16.
for j in range(0, 8):
17.
CRCLSB = (CRC & 0x0001);
18.
CRC = ((CRC >> 1) & 0x7FFF)
19.
20.
21.
22.
23.

if (CRCLSB == 1):
CRC = (CRC ^ 0xA001)
CRCHi = ((CRC >> 8) & 0xFF)
CRCLo = (CRC & 0xFF)
return (CRCLo,CRCHi)

24.
#Validao CRC
25.
def CRCvalid(resp):
26.
CRC = CRCcal(resp)
27.
if (CRC[0]==resp[len(resp)-2])
1]):return True
28.
return False

&

(CRC[1]==resp[len(resp)-

29.
30.
31.
32.
33.
34.
35.

#Modbus Funo 04 = Read Input Registers

def Func04Modbus(slave,start,NumOfPoints):
message = [0 for i in range(8)]
Slave_Address = slave
Function = 4
Starting_Address = start
Number_of_Points = NumOfPoints

36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.

#index0 = Slave Address

message[0] = Slave_Address
#index1 = Function
message[1] = Function
#index2 = Starting Address Hi
message[2] = ((Starting_Address
#index3 = Starting Address Lo
message[3] = (Starting_Address&
#index4 = Number of Points Hi
message[4] = ((Number_of_Points
#index5 = Number of Points Lo
message[5] = (Number_of_Points&

48.
49.

#CRC
CRC = CRCcal(message)

50.

#index6= CRC Lo

>> 8)& 0xFF)

0xFF)
>> 8)& 0xFF)
0xFF)

Pgina 30 de 38

ROBUSTA
ENGENHARIA
51.
52.
53.

message[len(message) - 2] = CRC[0]#CRCLo
#index7 = CRC Hi
message[len(message) - 1] = CRC[1]#CRCHi

54.
55.
56.
57.
58.
59.
60.

if ser.isOpen:
ser.write("".join(chr(h) for h in message))
responseFunc3total = 5 + 2 * Number_of_Points
reading = ser.read(responseFunc3total)
response = [0 for i in range(len(reading))]
for i in range(0, len(reading)):
response[i] = ord(reading[i])

61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.

if len(response)==responseFunc3total:
CRCok = CRCvalid(response)
if CRCok & (response[0]==slave) & (response[1]==Function):
#Byte Count in index 3 = responseFunc3[2]
#Number of Registers = byte count / 2 = responseFunc3[2] / 2
registers = ((response[2] / 2)& 0xFF)
values = [0 for i in range(registers)]
for i in range(0, len(values)):
#Data Hi and Registers1 from Index3
values[i] = response[2 * i + 3]
#Move to Hi
values[i] <<= 8
#Data Lo and Registers1 from Index4
values[i] += response[2 * i + 4]
negatif = values[i]>>15
if negatif==1:values[i]=values[i]*-1
return values
return ()

79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.

#Main Program
#Definio parametros da comunicao
try:
ser = serial.Serial(
port = '/dev/ttyUSB0',
baudrate = 9600,
bytesize = serial.EIGHTBITS,
parity = serial.PARITY_NONE,
stopbits = serial.STOPBITS_ONE,
timeout = 0.5
)
except Exception, e:
raise ValueError(e)

92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.

print "START"

#Mensagem para indicar inicio da interao

#Criao de 3 arrays de suporte

b1 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
b2 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
b3 = b1 + b2
#Declarao das variaveis de dados
Tensao = 0.0

Pgina 31 de 38

ROBUSTA
ENGENHARIA
103. Corrente = 0.0
104. Frequencia = 0.0
105. Potencia = 0.0
106. Potenciagerada = 0.0
107.
108. #Declarao da variavel de endereo, que ir dar suporte para
que se faa a leitura de todos os endereos
109.
110. end = 0
111.
112. #Criao do Arquivo de texto
113.
114. arq = open("Relat.txt", "w")
115. arq.write("RELATORIO")
116. arq.write("\n")
117. arq.close()
118.
119. #inicio do loop de leitura
120.
121. while 1:
122. #Serial Open Check
123. if not ser.isOpen:ser.open()
124. time.sleep(0.5)
125. #Read of Registers
126. Func04ArrayValue = Func04Modbus(1,end,2);#slave,start,number
of registers
127. if len(Func04ArrayValue)>0:
128. for i in range(0, len(Func04ArrayValue)):
129. #print
"Read
of
Registers"
+
str(i)
+
"
=
"
+
str(Func04ArrayValue[i])
130. if (i == 0):
131. j=0
132. while j<16 :
133. if ((Func04ArrayValue[i]) & (32768>>j)):
134. b1[j] = 1
135. else:
136. b1[j] = 0
137. j= j + 1
138. #print (b1)
139. if ( i == 1) :
140. j=0
141. while j<16 :
142. if ((Func04ArrayValue[i]) & (32768>>j)):
143. b2[j] = 1
144. else:
145. b2[j] = 0
146. j= j + 1
147. b3 = b1 + b2
148.
149. #Tratamento dos dados
150.
151. if b3[0]==1:
152. sinal = -1
153. if b3[0]==0:
154. sinal = 1
155. #print (sinal)
156. exp = 0
157. for i in range(1,8):

Pgina 32 de 38

ROBUSTA
ENGENHARIA
158. exp = exp + b3[i]*(2**(8-i))
159. #print (exp)
160. mantissa = 0.0
161. for i in range(9,31):
162. partmantissa = b3[i] + 0.0
163. mantissa = mantissa + partmantissa/(2**(i-8))
164. #print (mantissa)
165. f = sinal*(1 + mantissa)*2**(exp - 127)
166. #print(f)
167. if end == 14 :
168. Frequencia = f
169. if end == 16 :
170. Tensao = f
171. if end == 22 :
172. Corrente = f
173. if end == 28 :
174. Potencia = f
175. if end == 54 :
176. Potenciagerada = f
177. end = 0
178.
179. #Exposio dos dados na tela para acompanhamento
180.
181. print "#################################"
182. print("\n Tensao ")
183. print(Tensao)
184. print("\n Frequencia ")
185. print(Frequencia)
186. print("\n Corrente ")
187. print(Corrente)
188. print("\n Potencia ")
189. print(Potencia)
190. print("\n Potencia kwh ")
191. print(Potenciagerada)
192. print "#################################"
193.
194. #Alterando e salvando dados no arquivo de texto
195.
196. arq = open("Relat.txt", "a")
197. arq.write(" Tensao: ")
198. arq.write(str(Tensao) + " V")
199. arq.write("\n")
200. arq.write(" Corrente: ")
201. arq.write(str(Corrente) + " A")
202. arq.write("\n")
203. arq.write(" Potencia: ")
204. arq.write(str(Potencia)+ " kW")
205. arq.write("\n")
206. arq.write(" Potencia Gerada: ")
207. arq.write(str(Potenciagerada)+ " kWh")
208. arq.write("\n")
209. arq.write("############################")
210. arq.write("\n")
211. arq.close()
212.
213. #incrementando variavel de endereo, para ler
endereo
214.

Pgina 33 de 38

proximo

ROBUSTA
ENGENHARIA
215. end = end + 2

j) Utilizao de Threads em Python.

Quando preciso executar mltiplas aes em tempos diferentes. Por
exemplo, suponha que tenho que fazer leituras de sensores em freqncias
diferentes um a cada 10 segundos e outro a cada 15 segundos. Implementar
isso pode se tornar um pouco trabalhoso conforme o numero de sensores em
freqncias diferentes aumenta. Para isso, temos os threads que facilitam essa
implementao, com os threads basta criar uma classe ou funo para cada
sensor e depois executa las todas ao mesmo tempo, de maneira que uma no
vai nem saber da existncia da outra. Posso tambm configurar prioridades
nos sensores, e decidir qual deles deve ficar com a maior parte de
processamento.
Em Python existe um mdulo chamado thread, que pode ser facilmente
importado para o script.
Em seguida temos um cdigo exemplo que somente ir piscar dois LEDs
em freqncias diferentes:
1. import thread # Importa a Thread em Python 2.7
2. import time # Biblioteca de manipulaao de tempo
3. import RPi.GPIO as GPIO # Importa a biblioteca das GPIO
4. GPIO.setwarnings(False) # Desativa os avisos
5. GPIO.setup(18, GPIO.OUT) # Configura o pino 18, como sada
6. GPIO.setup(16, GPIO.OUT) # Configura o pino 16, como sada
7. # Define uma funao que funcionara em um processo a
8. # parte e que executara a cada 1 segundo sem parar
9.
def LED1(porta,tempo):
10.
while True:
11.
GPIO.output(porta, 1) # Acende o LED
12.
time.sleep(tempo) # Aguarda um tempo

Pgina 34 de 38

ROBUSTA
ENGENHARIA
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

GPIO.output(porta, 0) # Apaga o LED

# Define outra funo que funcionara em um processo a
# parte
def LED2(porta,tempo):
while True:
GPIO.output(porta, 1) # Acende o LED
time.sleep(tempo) # Aguarda um tempo
GPIO.output(porta, 0) # Apaga o LED
# Cria um processo que executa a funo LED1 a cada 1
segundo
thread.start_new_thread(LED1,(18,1))
# Cria um processo que executa a funo LED2 a cada 3
# segundos
thread.start_new_thread(LED2,(16,3))

Agora, posso comear a pensar em uma maneira de implementar isto no

projeto, na parte da comunicao e armazenamento de dados.
k) Utilizao do WebServer no Projeto.
Para a criao do WebServer vamos umas o Apache como software de do
webserver, e o MySQL para fazer o banco de dados. A primeira coisa a se fazer
instalar ambos. Com a seguinte linha de comando no terminal do Raspberry:

apt-get install apache2

php5 mysql-client mysql-server vsftpd

Ento a instalao se inicia e assim que terminar, ela pedi que se escolha uma
senha para o MySQL, no caso usei password como senha.
Depois disso j podemos visualizar uma pagina exemplo que j acompanha o
MySQL. Para acessar est pagina basta entra no navegador digitando o IP do
Raspberry como caminho http://<IP ADDRESS>, ao entrar no link aparece uma
pagina escrito que est funcionando, a pagina pode ser alterada no seguinte caminho
: /var/www/index.html.
Para criar uma base de dados no MySQL, basta entrar no terminal do
Raspberry, e digitar o comando de execuo do MySQL:

mysql ppassword

Pgina 35 de 38

ROBUSTA
ENGENHARIA
Depois disso pode se criar um banco de dados com o seguinte comando:
create database Monitoring;

Ento seleciona se o banco de dados:

use Monitoring;

E se cria a tabela:
create table EnergyMed (Tempo INTEGER UNSIGNED,Tensao DECIMAL(5,1),
Corrente

DECIMAL(5,1),

Potencia

DECIMAL(5,1),

PotenciaG

DECIMAL(5,1),

PotenciaR DECIMAL(5,1));

l) Transmisso dos dados.

Tendo em mos o Banco de dados criado anteriormente, foi elaborado um
script que fica responsvel por inserir e atualizar os dados no banco.
Depois de ter inserido ou atualizado os dados, os mesmos sero transmitidos
via HTTP ( Hypertext Transfer Protocol ) para outro banco de dados, o qual ser
responsvel pela publicao dos dados em uma pgina Web.
m) Adaptao do cdigo.
O cdigo produzido anteriormente acabou apresentando alguns problemas de
instabilidade, o que fazia com que o mesmo parasse de funcionar por problemas de
overflow ou coisas do tipo. Para que isso fosse resolvido, houve uma mudana na
forma como o cdigo foi desenvolvido. Utilizou o software Eclipse, para se elaborar
uma forma mais estruturada do cdigo. O que resultou em um cdigo mais limpo e
dividido em subclasses.

Consultas:
http://devlinuxbr.blogspot.com.br/2015/03/vamos-falar-de-python-threading.html
http://www.simplymodbus.ca/faq.htm#Modbus
http://www.cerne-tec.com.br/Modbus.pdf
Pgina 36 de 38

ROBUSTA
ENGENHARIA
http://www.modbus.org/specs.php
http://forums.ni.com/t5/Industrial-Communications/troubles-with-rs-485-on-Labview/mp/3132522/highlight/false#M2434
http://www.kronweb.com.br/br/downloads_manuais.php
Acompanhamento do cronograma:
1. Estudo Raspberry Pi;
- Noobs;
- Debian;
- Desenvolvimento em Python;
- GPIOs;
- Comunicao;
2. Comunicao Serial;
- Pacotes;
3. Comunicao Modbus;
- Modbus RTU;
- Desenvolvimento de software;
4. Adaptao do Software e criao do Banco de dados;
5. Multitarefa (Threds);
6. Entrega do prottipo funcional de aquisio;

Objetivos
Especficos

1
2
3
4
5
6

Abr

Mai

Jun

Jul

Ago

Set

Out

Nov

Dez

Jan

Fev

Mar

3. Informe se houve aplicao de recursos para a realizao das atividades

no perodo:
Pgina 37 de 38

ROBUSTA
ENGENHARIA
No.

4. Parecer sobre o andamento do projeto:

Elaborado o banco de dados e com adaptao do cdigo utilizando o eclipse.
O software ficou mais organizado e confivel. O que timo para o projeto. Agora
o prximo passo ser criar um cdigo para transmisso dos dados via HTTP e a
leitura de um arquivo.property que ir conter os dados do cliente onde ser
instalado o produto. Obtendo estes dados o nosso software ter conhecimento de
quem o cliente e poder criar uma identificao nos dados lidos no local.

5. Alguma outra organizao apoiou a execuo das etapas do projeto at o

momento? Se sim, quais foram as formas de auxlio?
No.

Pgina 38 de 38