Embarcando ScadaBR com Yocto na Toradex Colibri i.MX6

Introdução

  

Caro leitor, neste artigo iremos comentar sobre o que se trata um Sistema Scada, o que é o ScadaBR e o passo a passo para embarcar o ScadaBR em uma Placa Base IRIS e o módulo SOM Colibri i.MX6 da Toradex, e utilizar o Yocto Project para gerar uma imagem final pronta para receber o ScadaBR.

 

 

O que é um Sistema Scada

 

Um Sistema Scada vem do inglês referendo ao Sypervisory Control And Data Acquisition, em português conhecido como Supervisório e Aquisição de Dados. É um sistema que irá realizar o interfaceamento entre equipamentos, máquinas e sensores, ao computador onde o mesmo estará instalado, podendo atuar com diversas características como armazenamento de registros ("datalogger") e IHM (Interface Homem-Maquina) apresentando um painel de controle e gerenciamento para o operador.

 

 

Sobre o ScadaBR

 

O ScadaBR surgiu de um trabalho da MCA Sistemas com grande parceria e desenvolvimento da Fundação CERTI, Unis Sistemas e Conetec.

 

Um projeto 100% nacional, e o mais interessante é ser open-source, possibilitando a modificação e redistribuição do projeto respeitando as premissas do licenciamento adotado.

 

Um dos requisitos para o correto funcionamento deste software é possuir Java e o Apache Tomcat, o mesmo pode ser instalado em computadores com Windows ou Linux. Neste artigo estaremos portando para uma plataforma embarcada utilizando um processador ARM, e no final o sistema pode ser acessado via navegador de qualquer ponto que esteja na mesma rede do ScadaBR.

 

Os recursos para obter dados de sensores/equipamentos é bem amplo, por exemplo sendo Modbus (RS-232, RS485, TCP/IP, UDP/IP, HTTP, SNMP, SQL ou Data Source Virtual) e OPC DA baseado no OLE COM e DCOM da Microsoft e adotado por diversos desenvolvedores/fabricantes.

 

 

Preparando o ambiente host

 

O projeto foi customizado baseado no Yocto Project krogoth. Para sucesso neste processo as seguintes distribuições são oficialmente suportadas: 

  • Ubuntu
  • Fedora
  • OpenSUSE
  • CentOS
  • Debian

 

Para o correto funcionamento do ecossistema Yocto Project algumas ferramentas devem ser instaladas, mais detalhes acesse Required Packages for the Host Development System.

 

Ubuntu and Debian

 

$ sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath socat libsdl1.2-dev xterm

 

Fedora

 

$ sudo dnf install gawk make wget tar bzip2 gzip python unzip perl patch diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath ccache perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue perl-bignum socat findutils which SDL-devel xterm

 

OpenSUSE

 

$ sudo zypper install python gcc gcc-c++ git chrpath make wget python-xml diffstat makeinfo python-curses patch socat libSDL-devel xterm

 

CentOS

 

$ sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath socat perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue SDL-devel xterm

 

Todas dependências do host estão instaladas baseado em cada distribuição.

 

 

Baixando o manifesto do projeto

 

Para facilitar o trabalho de preparar no ambiente host o Yocto Project e baixar todas as camadas bem como suas revisões, foi criado um manifesto para auxílio, onde utilizando a ferramenta repo do Google irá gerenciar os repositórios e branchs para o projeto.

 

Instalando a ferramenta repo: 

$ mkdir ~/bin
$ PATH=~/bin:$PATH
$ curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
$ chmod a+x ~/bin/repo

 

Utilizando o repo para baixar e sincronizar os repositórios e branchs, para facilitar iremos criar o diretório scadabr-yocto para realizar o build: 

$ mkdir scadabr-yocto
$ cd scadabr-yocto
$ repo init -u git://github.com/cleitonbueno/scadabr-yocto-manifest.git -b krogoth
$ repo sync

 

 

Construindo a image

 

Desta maneira, no diretório scadabr-yocto teremos um diretório chamado poky-krogoth onde dentro do mesmo irá ter varias camadas que foram baixadas pelo repo, o próximo passo é criar o projeto e realizar pequenas alterações para nossa placa.

 

Esta etapa poderia ser automatizada também informando ao repo para usar configurações do projeto copiando o local.conf e bblayers.conf da camada meta-b2open, camada esta que possui a descrição da image scadabr-image e a receita para baixar, descompactar, configurar e instalar o Apache Tomcat 6, nesta camada também foi acrescentado um script que é configurado na image final para iniciar o Apache Tomcat6 durante o boot e encerrar no desligamento, e um arquivo que defini usuário e senha para acesso ao manager do Apache Tomcat6.

 

Porém, serão poucas alterações e é importante conhecer o arquivo que pode-se alterar para preparar o ambiente Java, Apache Tomcat6 e demais dependências para outras placas como Raspberry PI, Beaglebone Black entre outras.

 

Agora, criando o projeto, daremos o nome de build-scadabr

$ cd scadabr-yocto
$ source poky-krogoth/oe-init-build-env build-scadabr

 

Altere o build-scadabr/conf/local.conf conforme abaixo: 

#
# Machine qemux86 or Toradex Colibri i.MX6
#
#MACHINE ??= "qemux86"
MACHINE ?= "colibri-imx6"


# Accept EULA layer FSL
ACCEPT_FSL_EULA = "1"


#
# Reference: http://git.yoctoproject.org/cgit/cgit.cgi/meta-java/tree/README
#
# Possible provider: cacao-initial-native and jamvm-initial-native
PREFERRED_PROVIDER_virtual/java-initial-native = "cacao-initial-native"
# Possible provider: cacao-native and jamvm-native
PREFERRED_PROVIDER_virtual/java-native = "jamvm-native"
# Optional since there is only one provider for now
PREFERRED_PROVIDER_virtual/javac-native = "ecj-bootstrap-native"


#
# Where to place downloads
#
DL_DIR ?= "${TOPDIR}/../downloads"


#
# Where to place shared-state files
#
SSTATE_DIR ?= "${TOPDIR}/sstate-cache"


#
# Where to place the build output
#
TMPDIR = "${TOPDIR}/tmp"


#
# Default policy config
#
DISTRO ?= "poky"


#
# Package Management configuration
#
PACKAGE_CLASSES ?= "package_ipk"


#
# Extra image configuration defaults
#
EXTRA_IMAGE_FEATURES ?= "debug-tweaks"


#
# Additional image features
#
USER_CLASSES ?= "buildstats image-mklibs"


#
# Interactive shell configuration
#
PATCHRESOLVE = "noop"


#
# Disk Space Monitoring during the build
#
BB_DISKMON_DIRS = "\
  STOPTASKS,${TMPDIR},1G,100K \
  STOPTASKS,${DL_DIR},1G,100K \
  STOPTASKS,${SSTATE_DIR},1G,100K \
  STOPTASKS,/tmp,100M,100K \
  ABORT,${TMPDIR},100M,1K \
  ABORT,${DL_DIR},100M,1K \
  ABORT,${SSTATE_DIR},100M,1K \
  ABORT,/tmp,10M,1K"


CONF_VERSION = "1"

 

Altere o build-scadabr/conf/bblayers.conf conforme abaixo: 

POKY_BBLAYERS_CONF_VERSION = "2"

BBPATH = "${TOPDIR}"

BBFILES ?= ""

BBLAYERS ?= " \
  ${TOPDIR}/../poky-krogoth/meta \
  ${TOPDIR}/../poky-krogoth/meta-poky \
  ${TOPDIR}/../poky-krogoth/meta-yocto-bsp \
  ${TOPDIR}/../poky-krogoth/meta-openembedded/meta-oe \
  ${TOPDIR}/../poky-krogoth/meta-openembedded/meta-python \
  ${TOPDIR}/../poky-krogoth/meta-openembedded/meta-networking \
  ${TOPDIR}/../poky-krogoth/meta-b2open \
  ${TOPDIR}/../poky-krogoth/meta-java \
  ${TOPDIR}/../poky-krogoth/meta-fsl-arm \
  ${TOPDIR}/../poky-krogoth/meta-fsl-arm-extra \
"

 

Com as camadas configuradas, local.conf corretamente configurado podemos construir a image, usando a receita 'scadabr-image': 

$ source poky-krogoth/oe-init-build-env build-scadabr
$ bitbake scadabr-image

 

Teremos o seguinte conteúdo no diretório build-scadabr e seus respectivos tamanhos após a conclusão da construção: 

   19,8GiB [##########] /build-scadabr                                     
    3,9GiB [#         ] /downloads
  214,5MiB [          ] /.repo
   88,9MiB [          ] /poky-krogoth

 

Agora será feito o download de todas dependências de pacotes, ferramentas e utilitários, e o processo de build de cada item, este processo pode levar várias horas, no final a imagem será criada em build-scadabr/tmp/deploy/images/colibri-imx6/, bem como outros arquivos como bootloader, módulos do kernel, kernel, rootfs e o manifesto do rootfs. Veja o que foi gerado em nosso processo de construção: 

scadabr-yocto/build-scadabr/tmp/deploy/images/colibri-imx6 $ ls -1
modules--3.14.28-r0-colibri-imx6-20161013214310.tgz
modules-colibri-imx6.tgz
README_-_DO_NOT_DELETE_FILES_IN_THIS_DIRECTORY.txt
scadabr-image-colibri-imx6-20161014142907.rootfs.ext4
scadabr-image-colibri-imx6-20161014142907.rootfs.manifest
scadabr-image-colibri-imx6-20161014142907.rootfs.sdcard.gz
scadabr-image-colibri-imx6.ext4
scadabr-image-colibri-imx6.manifest
scadabr-image-colibri-imx6.sdcard.gz
u-boot-colibri-imx6.imx
u-boot-colibri-imx6-v2015.04-v2.5b3+gitAUTOINC+b66337d357-r0.imx
u-boot.imx
uImage
uImage--3.14.28-r0-colibri-imx6-20161013214310.bin
uImage--3.14.28-r0-imx6dl-colibri-cam-eval-v3-20161013214310.dtb
uImage--3.14.28-r0-imx6dl-colibri-eval-v3-20161013214310.dtb
uImage-colibri-imx6.bin
uImage-imx6dl-colibri-cam-eval-v3.dtb
uImage-imx6dl-colibri-eval-v3.dtb

 

 

Gravando a image e realizando boot

 

Nesta etapa deverá ter em mãos um cartão microSD, insira o mesmo e olhe nos logs do 'dmesg' para confirmar o nome do device, algo como /dev/sdX. Em seguida, acesse build-scadabr/tmp/deploy/images/colibri-imx6/scadabr-image-colibri-imx6.sdcard.gz, agora será feito a descompressão da image e na sequência a gravação para o microSD: 

$ cd build-scadabr/tmp/deploy/images/colibri-imx6
$ sudo gzip -d scadabr-image-colibri-imx6.sdcard.gz
$ sudo dd if=scadabr-image-colibri-imx6.sdcard of=/dev/sdX bs=1M

 

Após o término da gravação, insira o cartão na Placa Base IRIS, antes de alimentar será necessário conectar um cabo serial na Placa Base IRIS, alimentar a placa e interromper o bootloader e informar que o boot será através do microSD (run sdboot), este procedimento está descrito em detalhes no artigo Toradex Colibri iMX6 e Yocto Project Fido (1.8) na sessão Primeiro boot.

 

A seguir acessando algumas informações da imagem gerada, como versão do Java, as portas na escuta entre outras informações do ambiente em execução: 

[email protected]:~# java -version
java version "1.7.0_99"
OpenJDK Runtime Environment (IcedTea 2.6.5) (99b00-2.6.5)
OpenJDK Zero VM (build 24.95-b01, mixed mode)
[email protected]:~# 
[email protected]:~# free -m
              total        used        free      shared  buff/cache   available
Mem:            494         166         159           0         167         309
Swap:             0           0           0
[email protected]:~# 
[email protected]:~# netstat -tna
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       
tcp        0      0 0.0.0.0:111             0.0.0.0:*               LISTEN      
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      
tcp        0      0 ::ffff:127.0.0.1:8005   :::*                    LISTEN      
tcp        0      0 :::8009                 :::*                    LISTEN      
tcp        0      0 :::111                  :::*                    LISTEN      
tcp        0      0 :::8080                 :::*                    LISTEN      
tcp        0      0 :::22                   :::*                    LISTEN      
tcp        0      0 ::ffff:10.20.30.2:8080  ::ffff:10.20.30.45:36589 TIME_WAIT   
tcp        0      0 ::ffff:10.20.30.2:8080  ::ffff:10.20.30.45:36590 TIME_WAIT   
tcp        0      0 ::ffff:10.20.30.2:8080  ::ffff:10.20.30.45:36594 FIN_WAIT2   
tcp        0      0 ::ffff:10.20.30.2:8080  ::ffff:10.20.30.45:36596 FIN_WAIT2   
tcp        0      0 ::ffff:10.20.30.2:8080  ::ffff:10.20.30.45:36595 FIN_WAIT2   
[email protected]:~# 
[email protected]:~#
[email protected]:~# ps aux | grep java
root       627 15.7 22.0 446272 111608 ?       Sl   03:09   2:02 /usr/lib/jvm/jre/bin/java -Djava.util.logging.config.file=/usr/share/tomcat6/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djava.endorsed.dirs=/usr/share/tomcat6/endorsed -classpath /usr/share/tomcat6/bin/bootstrap.jar -Dcatalina.base=/usr/share/tomcat6 -Dcatalina.home=/usr/share/tomcat6 -Djava.io.tmpdir=/usr/share/tomcat6/temp org.apache.catalina.startup.Bootstrap start

 

 

Instalando e acessando ScadaBR

 

No final do boot o Apache Tomcat6 irá iniciar automaticamente, para confirmar que está funcionando. Abra o navegador e digite o IP da placa com a porta 8080, por padrão a placa irá subir como DHCP e irá aguardar atribuir um IP, sendo assim acesso com IP:8080, no meu caso o IP é http://10.20.30.2:8080. Na Figura 1 a tela inicial do Apache Tomcat.

 

ScadaBR com Yocto: Tela inicial Apache Tomcat
Figura 1 - Tela inicial Apache Tomcat

 

Próximo passo será realizar download do ScadaBR através do Downloads do site, baixando um arquivo chamado ScadaBR.war.

 

Em seguida, voltar à página do Tomcat e clicar no menu do lado esquerdo em Tomcat Manager, um usuário e senha é solicitado o default da instalação é admin/admin.

 

Deve rolar a página até em Deploy na parte referente a WAR file to deploy, como na Figura 2, onde irá procurar pelo arquivo ScadaBR.war baixado e salvo no computador e clicar em Deploy.

 

Tela Deploy arquivo WAR no Apache Tomcat
Figura 2 - Tela Deploy arquivo WAR no Apache Tomcat

 

Este processo pode levar alguns minutos, logo a seguir clicando em List Applications em Manager surgirá uma nova opção ScadaBR/, como pode ser visto na Figura 3.

 

Application Manager Apache Tomcat6
Figura 3 - Application Manager Apache Tomcat6

 

A aplicação ainda não está em execução para isso deve-se clicar na opção start logo à frente de ScadaBR/ e aguardar alguns minutos até a aplicação iniciar corretamente e ficar com a opção Running em true, como na Figura 4.

 

Iniciando aplicação ScadaBR no Application Manager do Apache Tomcat
Figura 4 - Iniciando aplicação ScadaBR no Application Manager do Apache Tomcat

 

Para confirmar que está funcionando com o mesmo IP que acessou o Tomcat, colocar IP:8080/ScadaBR/. Uma página como da Figura 5 será carregada, para acessar o logar no sistema o usuário e senha padrão é admin/admin.

 

Tela inicial do ScadaBR na Toradex Colibri i.MX6
Figura 5 - Tela inicial do ScadaBR na Toradex Colibri i.MX6

 

 

Considerações finais

 

A partir deste momento você possui uma image enxuta, com poucas ferramentas, sem interface gráfica e com script de inicialização automático para o Apache Tomcat6, dependências do Java e o ScadaBR operando.

 

Com poucas alterações pode-se portar esta image para outras placas alvos como Raspberry Pi e Beaglebone Black como já mencionado.

 

Foi customizado o arquivo /etc/tomcat-users.xml onde o usuário e senha para acessar do Manager é admin/admin. Este arquivo pode ser customizado a gosto do operador, recomendado a troca desta senha e criar outros perfis de acesso.

 

O database padrão é o Derby que já vem incorporado na aplicação, porém, o mesmo suporta MySQL mas para configurar o suporte deve-se alterar o .war, mais detalhes para este procedimento baixe o Manual do Software ScadaBR – 8. Dicas.

 

Para configurar e testar o ScadaBR, pode acessar e usar a série que o Daniel Madeira escreveu:

 

Estabelecendo comunicação via protocolo Modbus com ScadaBR

Criação de sistemas supervisórios simples com ScadaBR e Arduino

Criação de sistemas supervisórios dinâmicos com ScadaBR

Geração de relatórios com ScadaBr

Envio de dados por e-mail com ScadaBR

 

Esperamos que você tenha gostado do artigo, fique à vontade para enviar sugestões ou algum comentário.

 

Boa diversão!

 

 

Repositórios

 

https://github.com/cleitonbueno/scadabr-yocto-manifest/tree/krogoth

https://github.com/cleitonbueno/meta-b2open/tree/krogoth

 

 

Referências

 

http://www.scadabr.org.br/?q=node/1

https://www.embarcados.com.br/toradex-colibri-imx6-e-yocto/

http://www.yoctoproject.org/docs/2.1/mega-manual/mega-manual.html#packages

 

NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Cleiton Bueno
Proprietário da B2Open onde oferecemos consultoria, treinamentos e desenvolvimento em Sistemas Embarcados. Entusiasta a filosofia open-source, mais de 10 anos de experiências em Linux e FOSS. Em sistemas embarcado do firmware baremetal ao Linux Embedded, e há aproximadamente 8 anos desenvolvendo em (C, Python, Qt e muito Shell Script), além de profiling, hardening e tuning para targets com Linux Embarcado. Graduado em Engenharia da Computação pela UNICEP com ênfase em robótica e sistemas embarcados.

Deixe um comentário

avatar
 
  Notificações  
Notificar