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.
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
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 https://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: https://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:
root@colibri-imx6:~# 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)
root@colibri-imx6:~#
root@colibri-imx6:~# free -m
total used free shared buff/cache available
Mem: 494 166 159 0 167 309
Swap: 0 0 0
root@colibri-imx6:~#
root@colibri-imx6:~# 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
root@colibri-imx6:~#
root@colibri-imx6:~#
root@colibri-imx6:~# 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 é https://10.20.30.2:8080. Na Figura 1 a tela inicial do 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.
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.
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.
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.
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
Referências
