wordpress
Marcelo Martins ,
Chatbot no wordpress

Chat - Manager

Chat bot online
Teste de Chatbot
Tutorial de CSS

{{app}}

Conversa

Pergunta

{{msg}}

Objetivo

Neste tópico incluiremos o chatbot no wordpress, atraves de um shortcode.

Projeto GIT

O código deste projeto pode ser visto no git abaixo:

https://github.com/marcelomaurin/chatbot-wordpress

Ele permite criar um shortcode, que pode ser incluido nos posts.

Onde aparece uma pagina de chat, para que possa interagir.

[chatbot]

O chatbot pode ser incluído na página conforme o link acima.

O chatbot ja incluído nesta página

Nos próximos artigos iremos dar inicio ao código do chatbot, pois este esta apenas com a parte web atualmente.

Java
Marcelo Martins
Java sem nutela no Ubuntu – Parte 3

Estarei neste tópico apresentando como integrar linux com JAVA, de forma que possamos utilizar recursos do sistema operacional de forma que possamos ganhar maior agilidade.

Porque usar o SO

É interessante criar rotinas integráveis para o sistema operacional para ganhar agilidade e performace.

Como utilizar?

Podemos chamar aplicações:

  • shell script– Quando queremos agregar operações em lote, exemplo copiar uma pasta.
  • aplicação terceira – Quando queremos aproveitar features especificas da linguagem, exemplo uso de python para IA.

Quando não utilizar o SO

Existem muitos motivos para usar, e outros motivos que rejeitam o uso.

O mais importante motivo que rejeita seu uso, é quando queremos criar aplicações que não dependem do SO, podendo ser desacoplada de qualquer plataforma.

Aplicações

Aplicações de infra, necessárias para criação de serviços ou recursos, associados a um dado SO.

Podemos utilizar um serviço por exemplo para criar ambientes automatizados, criando ambientes de forma rápida e automática, replicando o que um operador faria em processos manuais.

Exemplos:

  • Clonagem de banco de dados
  • Copiar arquivos
  • Montagem de Serviços
  • Gestão de recursos do SO
  • Manipulação de containers ou serviços.
  • Gestão de testes integrados, etc

Como chamar aplicações

	public static int ProgExt(String Param01, String Param02)  throws IOException {
		int Resultado = 0;
		System.out.println ("Chamando ProgExt... ");
		Runtime rt = Runtime.getRuntime();
        String[] commandAndArguments = {"/home/mmm/projetos/meuproj/scripts/ScripExt.sh",  Param01, Param02 };
		System.out.println(commandAndArguments);
        try {
			String s;
			System.out.println ("ProgExt- Exec commandAndArguments completo");
			Process p = rt.exec(commandAndArguments);
			p.waitFor();
			Resultado = p.exitValue();
            System.out.println ("ProgExt- exit: " + Resultado);

            p.destroy();
		} catch(Exception ex) {
            ex.printStackTrace();
        }

		return Resultado;
	}

Ao Realizar a chamada o ScriptExt.sh, passamos os parâmetros, conforme o script abaixo:

#!/bin/bash

ORIGEM=$1
DESTINO=$2

PATH=/home/mmm/projetos/meuproj/scripts


echo "Inicio de Log" >  $PATH/logbkp.log
echo "Iniciando copia de arquivo" >>  $PATH/logbkp.log

/usr/bin/cp -r $ORIGEM $DESTINO >>  $PATH/logbkp.log

O modelo deste script, permite capturar pela shell script os parâmetros recebidos do JAVA, realizando tarefas via scripts, permitindo aproveitar o que o JAVA teria maior dificuldade em realizar.

De fato a automação de cópia, não se enquadra em tarefa difícil, porem em um processo didático exemplifica sua prática.

Outro Exemplo seria copia de banco de dados:

#!/bin/bash

#exemplo de teste
#sh -x  ./clonabanco.sh bancoorigem bancodest

PATH=/home/mmm/projetos/meuproj/scripts

echo "Script de replicação de banco"

databaserep=$1

database=$2

output="output.sql"


echo "Log de execucao da operacao de clonagem de banco" >>  $PATH/logbkp.log

echo "Origem:$databaserep" >>  $PATH/logbkp.log
echo "Destino:$database" >>  $PATH/logbkp.log
echo "Data:`/usr/bin/date`" >>  $PATH/logbkp.log



echo "Iniciando criacao de backup " >>  $PATH/logbkp.log
echo `/usr/bin/mysqldump -uroot -pSENHA $databaserep -r $PATH/output.sql` >> $PATH/logbkp.log


echo "Escrevendo script de copia" >>  $PATH/logbkp.log

echo "CREATE DATABASE $database;"> $PATH/copy.sql
echo "use $database" >> $PATH/copy.sql
echo "SOURCE $PATH/output.sql" >> $PATH/copy.sql

echo "Criando a base destino" >>  $PATH/logbkp.log

echo `/usr/bin/mysql -uroot -pSENHA < $PATH/copy.sql` >> $PATH/logbkp.log

echo "Fim de execução " >>  $PATH/logbkp.log

Podemos ver neste script, o uso de técnica de clonagem do banco de dados, permitindo a integração simples com JAVA.

Com este ultimo artigo, encerramos a série de artigos Java sem Nutela no Ubuntu, espero que tenham gostado.

wordpress
Marcelo Martins , , ,
Personalização do WordPress

Os templates tags são informações obtidas do wordpress, que facilitam a captura das informações pelo site.

A lista de templates é muito variada, e pode ser vista no site:

https://codex.wordpress.org/Template_Tags

Mas podemos destacar alguns:

  • the_tags – lista de tags marcados no post.
  • the_category – lista de categorias marcadas no post.

Rodando Querys

É possível rodar uma query incorporada, lendo informações do banco do wordpress, conforme exemplo:

global $wpdb;

$sql = "select * from $wpdb->posts where post_status = 'publish'");

$listagem = $wpdb->get_results($sql);

foreach ($listagem as $value){
    echo $value->post_title;
    echo $value->post_content;
}

Usando WP_QUERY

O WP_QUERY é um query modificado, permitindo fazer filtragens por parâmetros.

$posts = new WP_Query('posts_per_page=1&orderby=rand');

while($posts->have_posts()): $posts->the_post();
    echo the_title();
    echo the_content();
endwhile;

Estarei dando maior foco no WP_Query em outros posts.

Tornar um WORDPRESS restrito

Uma forma simples de restringir o conteúdo de um wordpress, é exigir autenticação.

Isso pode ser visto, se incluirmos no arquivo header.php o seguinte fragmento:

<?php
if (!is_user_logged_in() ){
Header( "location:wp-admin/" );
}
?>

HOOK – Ganchos

Add_Filter

O Add_filter permite interceptar um dado, antes da sua visualização na tela.

Ele utiliza um callback, que é chamado na ocorrência do evento.

Exemplo, exibição do titulo

<?php
add_filter('the_title','view_title', 10,2);

function view_title($value, $id){
  if ($value== "NOVO") {
    $value = "NEW";
  }
  return value;
}
?>

No exemplo toda vez que um Titulo vier com nome novo, ele será substituído por NEW.

Add_action

O add_action é um evento que ocorre no momento da execução do wordpress, que é disparado durante a execução de alguma etapa de montagem da página.

Exemplo, podemos chamar a função inicializa, no momento da inicialização da página.

<?php
add_action('init','inicializa');

function inicializa(){
  echo 'Inicializou';
}

Java
Marcelo Martins
Java sem nutela no Ubuntu – Parte 2

Neste segundo artigo, Java sem nutela, vamos explicar como desenvolver uma aplicação na mão, sem IDE.

No primeiro artigo, expliquei como gerar um hello world, sem nada.

GIT

https://github.com/marcelomaurin/Java-Hello-World

Neste segundo artigo iremos incluir um arquivo de biblioteca JAR alem de explicar o conceito do JAR.

O JAR na verdade é um pacote contendo vários arquivos java, alem de outras informações referentes a criação de um pacote.

Usando um JAR

Primeiro irei explicar como usar o JAR.

O Arquivo JAR deve estar localizado em uma pasta onde os .JAR sejam encontrados, de forma geral, o linux ou qualquer outro sistema operacional, precisa visualizar a variável CLASSPATH

Para isso, iremos alterar o Makefile, incluindo o caminho da nossa lib

JCC=javac
SOURCE= \
	hello.java

TARGET= HelloWorld
PATHLIB=$CLASSPATH:/~/Java-Hello-World/libs

DEBUG= -g

all: compile run

lib:
	export CLASSPATH=$(PATHLIB)

compile:

	$(JCC) $(DEBUG) $(SOURCE)

run:
	java $(TARGET)

A lib só deve ser chamada um unica vez podendo ser incluída nos scripts de inicialização.

make lib

Pronto agora é só incluir seu jar na pasta que vc definiu no script e importar ele no seu código.

Criando seu JAR

A criação do JAR é bem simples, parte do meu artigo foi baseado no git https://github.com/macagua/example.java.helloworld

Meu GIT

https://github.com/marcelomaurin/hello-java

Nele podemos ver o Makefile

JCC=javac
SOURCE= \
	./HelloWorld/Hello.java

TARGET= HelloWorld

CLASS=Hello

DEBUG= -g

all: compile run

compile:
	$(JCC) $(DEBUG) $(SOURCE)

jar:
	jar cfm $(CLASS).jar Manifest.txt  $(TARGET)/$(CLASS).class


run:
	java -cp . $(TARGET).$(CLASS)

runjar:
	java -jar $(CLASS).jar

São dois pontos importantes para discusão.

A criação do jar pelo comando:

jar cfm $(CLASS).jar Manifest.txt $(TARGET)/$(CLASS).class

O jar é o pacote responsável pela criação dos pacotes jar.

No exemplo seguinte, vemos o pacote executado

java -jar $(CLASS).jar

onde o comando testa o pacote.

Criação do Pacote

Criação do Manifest.txt, é o arquivo responsável por dizer o que é.

Manifest-version: 1.0
Created-By: 1.0 (Maurinsoft)
Main-Class: HelloWorld.Hello

Nele encontramos apenas a descrição da classe que será criada (MAIN-CLASS)

Por ultimo os fontes Hello.java

package HelloWorld;

// Meu primeiro programa
class Hello {
	public static void main(String[] args) {
        	System.out.println("Hello, World!");
        }
}

Verificamos neste artigo, que o empacotamento, de fato é uma atividade bem simples e fácil de ser realizada manualmente.

Java
Marcelo Martins , , , ,
Java sem nutela no Ubuntu

Muitas vezes em C temos que compilar o projeto na mão.

A maioria das linguagens tem essa opção, vou explicar como fazer isso sem IDE de desenvolvimento, usando o VI no java.

Instalação

Para instalar o java vamos chama o terminal

sudo apt install openjdk-17-jdk-headless

Temos agora o ambiente montado, para começar a montar nosso projeto.

Git

git do projeto montado.

https://github.com/marcelomaurin/Java-Hello-World

Criando o Hello World

Criaremos o famoso Hello World, pois existe a lenda que se não criarmos ele no começo, tudo dá errado. Então vamos seguir:

Fonte: hello.java

// Meu primeiro programa
class HelloWorld {
        public static void main(String[] args) {
                System.out.println("Hello, World!");
        }
}

Agora para testar, vamos executar ele direto, executando o script:

java hello.java

Segue o exemplo de sua execução:

Chamando o hello.java

Agora iremos criar o script para compilação:

Arquivo: Makefile

JCC=javac
SOURCE= \
        hello.java

TARGET= HelloWorld

all: compile run

compile:
        $(JCC) $(SOURCE)

run:
        java $(TARGET)

Para compilar, chamamos o make compile, e para executar o make run , conforme figura abaixo:

Debugando o java

Para debugar o fonte temos que compilar o projeto com a opção -g, conforme segue o script do Makefile alterado.

JCC=javac
SOURCE= \
        hello.java

TARGET= HelloWorld

DEBUG= -g

all: compile run

compile:
        $(JCC) $(DEBUG) $(SOURCE)

run:
        java $(TARGET)

O parametro -g, cria os espaços de debug necessários para o debug.

Ao compilar agora, podemos chamar o debug em Java.

O jdb é semelhante ao gdb do C, para executar o mesmo, chamamos o nosso programa conforme exemplo abaixo:

jdb HelloWorld

rodando com Debug

Podemos verificar que o código foi rodado inteiramente, pois não tinhamos breakpoints.

Para incluirmos o break point usamos o comando:

stop in [classe].[metodo]

Para rodar no debug use o comando:

run

Conforme figura abaixo:

Debug pela console

Para continuar usamos o step, e o print mostra a variavel.

Com isso, mostramos as funcionalidades básicas para analisar e rodar uma aplicação Java pelo terminal, sem necessidade de incluir uma IDE.

Espero que tenham gostado, críticas e comentários, fico no aguardo.

C/C++ Python
Marcelo Martins , , , ,
Cython – Integração entre Python e C/C++ – Segunda Parte

Neste segundo artigo, iremos criar um projeto em C, em seguida desenvolver um projeto Hello World em Python, que iremos chamar no C e compilar.

GITHUB

https://github.com/marcelomaurin/cython

Primeiramente vamos criar nosso projeto em C.

Primeiramente criamos um arquivo Makefile

CC= gcc
SAMPLE=sample.pyx
LIBS= `pkg-config --cflags --libs python3`
TARGET=hello
SOURCE= \
hello.c \
sample.c



all: clean compile install

clean:
	rm ./sample.c
	rm ./sample.h


compile:
	cython ./$(SAMPLE)
	$(CC) $(SOURCE) $(LIBS) -o ./$(TARGET)

install:
	cp ./$(TARGET) /usr/local/bin/

No exemplo acima, temos dois pontos chaves no nosso código.

A inclusão do sample.pyx que irá ser convertido em um sample.c e um sample.h, conforme script do compile.

Agora iremos mostrar o código do C, que chamará o python, nosso código: hello.c

#include <stdio.h>
#include "sample.h"

int main()
{
	call_hello();
}

Neste código vemos uma chamada para a lib sample.h, que será criada pelo cython a partir do script.

A função Call_hello é declarada já no python, e a seguir vemos como ela é apresentada.

Fonte: hello.pyx

from sam import sam

cdef public void call_hello():
	sam.hello()

Agora iremos escrever o sam.py, que será chamado:


def hello():
    print("Hello World")

Por fim, compilamos o script:

make compile

E rodamos o mesmo

./hello

Documentação de Apoio

https://riptutorial.com/Download/cython.pdf

Fóruns e Artigos coligados

Blog C/C++ Python
Marcelo Martins
Cython – Integração entre Python e C/C++

Cython é uma ferramenta de integração Entre Python e C/C++, permitindo criar interfaces integráveis entre as duas linguagens.

O uso do cython tende a auxiliar ambos os programadores dos dois mundos.

Para os programadores C/C++ o uso do python permite criar funções mais dinâmicas e rápidas de serem construídas. Permitindo acesso a tecnologias que o programador C demoraria mais para construir nas interfaces nativas.

Para o programador Python, permite utilizar todo o poder o C e C++ integrado com códigos rápidos e ágeis do Python.

Estaremos neste artigo, instalando o cython na máquina, e no próximo criando um case para que possamos utiliza-lo.

Abordaremos apenas a instalação do cython, pois entendemos que os demais ambientes são de responsábilidade dos desenvolvedores.

Instalação do Cython no Linux

Para instalar o cython é necessário ter o python 3.7 ou superior.

Caso tenha uma versão menor, será necessário atualizar sua versão.

A instalação é bem simples, basta digitar:

pip install cython

Lazarus MNote2
Marcelo Martins
Liberado a versão 2.10 Linux

Foi liberado a versão 2.10 linux, a versão 2.10 linux contem alguns ajustes na plataforma.

A versão pode ser baixada pelo repositório GIT no seguinte caminho:

https://github.com/marcelomaurin/MNote2/blob/master/bin/mnote2-2.10_amd64.deb

As modificações necessárias para compilar na 2.10 Linux, serão refletidas na 2.11 Windows.

E tratam de ajustes em macros de ambiente e modificações na integração entre synedit e TItem.

Os ajustes foram necessários pois o tamanho do ponteiro no linux do TSynedit não comportava o armazenamento de classe.

Então foi necessário modificar o Item, e o painel para armazenar o item, ao invés do Tsynedit, e desta forma referenciar ele no através do Titem.

MNote2
Marcelo Martins
MNote2 – Correções Versão 2.10

Estou preparando uma nova versão do editor MNote2.

Com algumas correções identificadas, o MNote2, vem com algumas melhorias.

  • Correção arquivos de Configuração
  • Correção nas rotinas associadas a TSynCompletion
  • Inclusão de rotinas associadas a TSynAutoComplete
  • Correção de carga de arquivos por parâmetros em prompt
  • Libs de acesso ao Banco Mysql/Postgres/Sqlite

Correção arquivos de Configuração

Este problema foi identificado, pois os arquivos de configuração estavam em pasta que exigia permissão de administrador para serem modificados.

Houve uma alteração no código dos arquivos de configuração, permitindo que os arquivos sejam gravados sem permissão especial. Tambem foi agregado condicionais de compilação (diretivas) para permitir customização caso necessário para ambientes heterogênios.

Fontes modificados:

  • setmain.pas
  • setbanco.pas
  • setFolder.pas
  • setMQuery.pas

Tipo de mudança

Foi criado uma variavel

 FPATH : string;

Foram adicionados os caminhos do FPATH, nas funções IdentificaArquivo e SalvaContexto, dos fontes acima.

Correção nas rotinas associadas a TSynCompletion

Este problema ocorre na indicação do código para apontamento da classe TSynCompletion.

O ponto correto é através da classe TItem, na propriedade synCompletion.

No código havia dois pontos divergentes.

Inclusão de rotinas associadas a TSynAutoComplete

Neste processo associado, inclui código da classe TSynAutoComplete, que é um complemento da estilização de código, onde o sistema propoem blocos associados a tipo.

Esta rotina fica criada na main.pas, mas é indicada na Item.pas.

AutoComplete : TSynAutoComplete;

O código é criado na função NovoItem, onde é criado o objeto, que posteriormente é manipulado diretamente pela classe TItem.

function TfrmMNote.NovoItem():TTabSheet;
var
   tb : TTabSheet;
   syn : TSynEdit;
   item : TItem;
   SynCompletion : TSynCompletion;
   synAutoComplet : TSynAutoComplete;
begin
  tb := pgMain.AddTabSheet();

  syn := TSynEdit.Create(tb);
  syn.Parent := tb;
  syn.Align:= alClient;
  syn.Lines.Clear;
  syn.PopupMenu := popSysEdit;
  syn.OnChange:= @synChange;
  (*Complete*)
  SynCompletion := TSynCompletion.Create(self);
  SynCompletion.Editor := syn;
  SynCompletion.OnCodeCompletion:=@SynCompletion1CodeCompletion;
  SynCompletion.OnExecute:=@SynCompletion1Execute;
  SynCompletion.OnSearchPosition:=@SynCompletion1SearchPosition;

  (*Autocomplete*)
  synAutoComplet := TSynAutoComplete.create(self);
  synAutoComplet.Editor := syn;

  tb.PopupMenu := popFechar;
  tb.Tag:= Integer(pointer(syn)); //Guarda o Sys
  tb.ImageIndex:=0;

  item := TItem.create();
  item.AtribuiNovoNome();
  item.synCompletion:= SynCompletion;    //Ponteiro de SynCompletion
  item.AutoComplete :=  synAutoComplet;  //Ponteiro de synAutocompletion

  syn.Tag:= longint(pointer(item));
  tb.Caption:= item.Name;
  pgMain.Refresh();
  application.ProcessMessages;
  result := tb;
end;

Correção de carga de arquivos por parâmetros em prompt

Neste problema, identificamos que ao tentar realizar a carga do programa por parâmetro o mesmo não era iniciado.

Após analise, identificamos que o problema do programa era associado ao painel.

O programa estava pegando sempre o item atual, desta forma ele modificava o item errado.

Uma correção foi implementada.

      tb := NovoItem();

      //tb := pgMain.ActivePage;
      syn := TSynEdit(tb.tag);
      try
        item := Titem(syn.tag);
        fSynCompletion := item.synCompletion;
        fAutoComplete := item.AutoComplete;
        syn.Lines.LoadFromFile(arquivo);

        item.ItemType := classificaTipo(arquivo);

Foi mudado o NovoItem, passando de Procedure para Function, onde passo o tb diretamente, sem necessidade de capturar.

tb := pgMain.ActivePage;

O erro era justamente na rotina acima. Que foi comentada nos testes e posteriormente apagado.

Libs de acesso ao Banco Mysql/Postgres/Sqlite

Preparação para próxima versão, onde já contempla libs de conexão de banco de dados.

Criação da Pasta Libs, contemplando arquivos de conexão há bancos de dados.

Revisão e lançamento das versões

As correções serão lançadas em master no git e estarão disponíveis na versão 2.10.

pós graduação
Marcelo Martins
Analise do Material

Atividade destinada ao curso de Pos graduação UNINOVE.

Artigo

Article
Fuzzy-Based Statistical Feature Extraction for
Detecting Broken Rotor Bars in Line-Fed and
Inverter-Fed Induction Motors

Cleber Gustavo Dias 1,* , Luiz Carlos da Silva 1 and Ivan Eduardo Chabu 2

Analise do material

Objetivo do material

Identificar disturbios na barra de rotor através de sensoriamento.

São os sensores Efeito Hall (efeito de campo magnético) o mesmo utilizado em estradas.

Permitindo identificar a existência, mas o comprometimento da barra.

No método aplica-se um tenção de 7,5KW alimentada por um inversor

Introdução

Apresenta uma visão da necessidade, bem como do ambiente industrial aplicado. Onde máquinas são movidas por motores elétricos.

Ele aponta alguns problemas:

  • Rolamento dos motores
  • gaiola do rotor
  • Mancais

Estima-se que paradas não previstas , geram uma perda de receita de US$2,5 a US$4.0 milhões.

Falhas possíveis

  • malha fechada
  • vazamento detectado por escorregamento muito baixo,componente da banda lateral esquerda

Tempo de leitura

aproximadamente 100s, ou seja 1 minuto e meio de leituras amostrais.

Metodologias e propostas de analise

Baseadas em Transformada wavelet Discreta (DWT) e Transformada de Fourier de Tempo Curto (STFT).

Falhas em máquinas rotativas,
como abordagens no domínio do tempo e no domínio da frequência, bem como o uso de KNN, SVM e Fuzzy
Classificadores c-Means, entre outros.

Este artigo apresenta o uso de um sistema de inferência fuzzy (FIS) para extrair as características de um sensor Hall sinal, instalado dentro do motor, de acordo com a condição do rotor.

945 / 5.000

Resultados de tradução

(i) Não é necessário estimar o escorregamento do rotor, conforme exigido pelo método MCSA e outras técnicas
(relacionado à indicação de FN);
(ii) É possível detectar barras quebradas durante a variação de carga (relacionada à indicação FN);
(iii) É possível detectar barras quebradas durante oscilações de carga de baixa frequência (relacionadas à indicação de FP);
(iv) É possível classificar a gravidade das falhas do rotor;
(v) É possível detectar barras de rotor rompidas para motor funcionando em baixo escorregamento (relacionado à indicação FN);
e
(vi) O método permite a detecção de falhas do rotor para motores alimentados por um inversor e também alimentados por
fonte de energia.

A presente abordagem foi validada usando resultados de simulação de dois IMs (1200 kW e
7,5 kW) e foram realizados testes experimentais utilizando um motor de indução de 7,5 kW, 220 V e
38 barras de rotor, alimentadas por uma alimentação senoidal e por um inversor. A metodologia e os resultados são
apresentados nas subseções a seguir.

Artigo 2

Developing IoT Sensing System for
Construction-Induced Vibration Monitoring and
Impact Assessment

Neste artigo, a justificativa do trabalho se baseia no crescimento vertical , onde analise de vibrações tem ligação direta com processos construtivos. Garantindo qualidade e segurança.

O projeto justifica seu uso, e apresenta um sistema robusto porem de baixo custo baseado em solução raspberry, bluetooth e 4G

Sensores IoT

Developing IoT Sensing System for
Construction-Induced Vibration Monitoring and
Impact Assessment

Qiuhan Meng and Songye Zhu *
Department of Civil and Environmental Engineering, The Hong Kong Polytechnic University,
Hong Kong, China; qiuhan.m.meng@connect.polyu.hk

  • Correspondence: songye.zhu@polyu.edu.hk; Tel.: +852-34003964

Utilizando um raspberry pi, conectado a um dispositivo 4G ligado ao sensor acelerometro pela porta GPIO, conforme figura abaixo:

Tabela de resolução do equipamento LSM9DS1

A comunicação e internet

Se dá através de dong USB 4G.

Velocidades de conexão variam, podendo chegar

Fornecimento de energia

O consume do RASPBERRY é baixo, e estima-se que um painel de 50W, ligado a uma bateria de 20Ah com 12V possa fornecer 28h de energia ininterrupta, mesmo sem recarga, e que o painel de 50W possa recarregar em 7H. Sendo mais que suficiente para sua alimentação.

Software

O Software necessário precisa ler o GPIO , lendo o dispositivo I2C, gravando em um arquivo CSV.

Conforme fluxograma

A sincronização de tempo se dá pelo serviço de NTP.

Como os relogios são sincronizados pelo mesmo servidor ntp, os times são bem precisos, com uma diferença estimada em 10ms

Armazenamento na nuvem

Se dá através de um servidor em nuvem, através de aplicação conforme exemplo a seguir

Comparado com um equipamento industrial, o uso do raspberry, teve uma diferença de 3% em média menor, nos valores amostrados, mostrando uma confiabilidade em diferentes tipos de frequencia.

Resumo e Discussão

Este estudo apresenta o projeto, desenvolvimento e validação de um sistema de sensoriamento IoT sem fio para
monitoramento de vibração induzida pela construção em tempo real e avaliação de impacto. O hardware do
O sistema de detecção IoT desenvolvido consiste na placa Raspberry Pi, acelerômetro MEMS, Internet 4G
dongle e bateria solar. O Raspberry Pi é usado para coletar e analisar sinais digitais medidos por
o acelerômetro MEMS. Processamento de sinal local, incluindo filtro de dados, integração e avaliação de
níveis de vibração em tempo real em relação ao PPV, velocidade RMS na banda de 1/3 de oitava e aceleração RMS
Sensores 2020, 20, 6120 21 de 23
em banda de 1/3 de oitava, são realizados no Raspberry Pi. Os dados brutos e processados, bem como os
os resultados analisados ​​são transmitidos para o banco de dados MySQL na nuvem pública através do celular 4G
rede em tempo hábil. Painéis solares com bateria recarregável são usados ​​como fonte de energia contínua
fornecer. O software de operação e o mecanismo de sincronização de tempo NTP são desenvolvidos de acordo.
As funções de banco de dados e alarme são implementadas no sistema em nuvem. Além disso, uma página da web
interface do usuário é desenvolvida para exibir resultados de medição em tempo real e sinais de alarme, que podem
ser acessado remotamente a partir do computador autorizado ou dispositivos móveis via Internet. O saliente
Os recursos do sistema de detecção de vibração IoT incluem: (1) tamanho pequeno e sensor sem fio autônomo
nós que permitem fácil instalação sem qualquer trabalho de cabeamento, (2) baixos custos de hardware e baixo consumo de energia
consumo, (3) nós de sensores independentes evitando rede hierárquica de sensores, (4) dados confiáveis
transmissão sem perda de dados, (5) sincronização de tempo NTP permitindo amostragem de dados de alta precisão,
e (6) processamento de dados em tempo real, avaliação de vibração e capacidade de alarme.
A precisão do acelerômetro MEMS selecionado (LSM9DS1) foi verificada através do
comparação com o acelerômetro tradicionalmente com fio nos experimentos de laboratório. Além disso, a IoT
sistema de detecção de vibração foi testado em um local de constrição real em Hong Kong com estaca-prancha em andamento
trabalho de construção. Os resultados experimentais de laboratório e de campo indicaram que o
O sistema de detecção IoT pode medir vibrações induzidas pela construção com precisão satisfatória em ambos
domínio do tempo e da frequência. O poder computacional do Raspberry Pi e da nuvem permite que o
cálculo em tempo real de diferentes indicadores de vibração e avaliar o impacto da vibração comparando
vários limites de vibração pré-especificados. Este sistema de detecção de vibração IoT será implementado em breve
em outro canteiro de obras em Hong Kong para monitoramento de impacto de vibração de construção a longo prazo
e avaliação.
Notavelmente, o Raspberry Pi é uma plataforma de código aberto que permite conexões com vários tipos de
sensores com portas compatíveis. Portanto, o sistema de detecção IoT desenvolvido pode ser convenientemente estendido
a outras funções de monitoramento, como microfones MEMS para medição de ruído, temperatura e
sensores de umidade para monitoramento ambiental, sensores ultrassônicos para detecção de danos e
sensores de vibração de sensibilidade, se necessário.
Contribuições dos autores: Conceituação, metodologia, software, validação, investigação, curadoria de dados e
redação—preparação do rascunho original: Q.M.; Conceituação, redação – revisão e edição, supervisão, projeto
administração e aquisição de financiamento: S.Z. Todos os autores leram e concordaram com a versão publicada de
o manuscrito.
Financiamento: Esta pesquisa foi financiada pelo Conselho da Indústria da Construção de Hong Kong (número de concessão: CICR/03/18)
e a Universidade Politécnica de Hong Kong (número da concessão: Projeto No. ZE1F).
Conflitos de interesse: Os autores declaram não haver conflito de interesse.

Minhas referencias

http://maurinsoft.com.br/index.php/2022/05/27/integrando-python-com-php/

http://maurinsoft.com.br/index.php/2022/02/04/mysql-com-c-lazarus-python-php-r-parte-3/

http://maurinsoft.com.br/index.php/2022/01/31/mysql-com-c-lazarus-python-php-r-parte-1/

Objetivo – Analise do Artigo

O projeto visa estabelecer a base de um hardware suficiente para captura de vibraçoes, propiciando a captura e envio das informações para um servidor em nuvem.

Entendendo como a captura é realizada, através de um raspberry PI, que é um equipamento fornecido por uma organização sem fins lucrativos A Fundação Raspberry PI www.raspberrypi.org [https://pt.wikipedia.org/wiki/Raspberry_Pi_Foundation].

Na qual provê alem do equipamento, tambem um sistema operacional RASPIAN (linux like), no qual permite o desenvolvimento de diversos projetos embarcados com grande flexibilidade e robustes.

Instalação do Serviço de NTP

Uma das primeiras coisas que são feitas no equipamento, é o cuidado com a sincronização dos tempos.

A sincronização dos tempos é feita através de um serviço de NTP, que é Network Time Protocol [https://ntp.br/]. O NTP garante sincronização dos tempos baseados em servidores de tempo ultra precisos, espalhados pelo mundo. No caso usaremos o servidor a.st1.ntp.br.

Este servidor foi estabelecido pois tem tempo de resposta entre 12.ms1 e 12.9ms.

Instalando o SSH

Após a instalação do Servidor de NTP, será necessário instalar um serviço de manutenção de ssh, para propiciar a conexão remota nos equipamentos. O procedimento para realização pode ser visto no link [https://roboticsbackend.com/enable-ssh-on-raspberry-pi-raspbian/]

Após a instalação de um serviço é necessário o acesso a internet.

No Raspberry PI, isso é feito de duas formas, no nosso caso usaremos o processo de conexão via WIFI, que permite conectar através de uma rede. Lendo as informações de acesso. O procedimento de configuração de um wifi, pode ser visto conforme segue [https://pplware.sapo.pt/linux/tutorial-raspberry-pi-configurar-wireless-via-linha-de-comandos/]

Instalando um servidor web

A instalação do equipamento, agora será necessário permitir configurar um serviço de monitoramento web, para que possamos conectar aparelhos como celular ou tablets a fim de obter leituras do dispositivo. Para tanto usaremos um servidor APACHE/PHP, realizando o procedimento de instalação conforme o apresentado. [https://randomnerdtutorials.com/raspberry-pi-apache-mysql-php-lamp-server/]

Para analise de dados usaremos o python para realizar a leitura dos dados amostrados.

Para tanto usaremos um processo de integração direto, entre o PHP/Python, conforme apresentado no link abaixo:

[https://maurinsoft.com.br/index.php/2022/05/27/integrando-python-com-php/]

Conexões com Hardware

Depois de montado o sistema operacional e criado uma versão funcional do linux com os requisitos minimos necessários para a manutenção, iremos suprir o hardware necessário.

As conexões com o raspberry são realizadas conforme figura abaixo, gentilmente fornecida pelo site:

Análise de acelerômetro, giroscópio e magnetômetro com Raspberry Pi Parte I: leituras básicas

O procedimento de criação bem como captura das informações tambem estão disponíveis no site acima referenciado.

Ficando apenas de referencia o codigo

# deve ser salvo na pasta local com o nome "mpu9250_i2c.py"
# será usado como controlador I2C e porto de função para o projeto
# consulte o datasheet e registre o mapa para obter uma explicação completa
import smbus,time
def MPU6050_start():
    # alterar a taxa de amostragem (estabilidade)
    samp_rate_div = 0 # sample rate = 8 kHz/(1+samp_rate_div)
    bus.write_byte_data(MPU6050_ADDR, SMPLRT_DIV, samp_rate_div)
    time.sleep(0.1)
    # redefinir todos os sensores
    bus.write_byte_data(MPU6050_ADDR,PWR_MGMT_1,0x00)
    time.sleep(0.1)
    # gerenciamento de energia e configurações de cristal
    bus.write_byte_data(MPU6050_ADDR, PWR_MGMT_1, 0x01)
    time.sleep(0.1)
    #Write to Configuration register
    bus.write_byte_data(MPU6050_ADDR, CONFIG, 0)
    time.sleep(0.1)
    #Escrever no registro de configuração do Gyro
    gyro_config_sel = [0b00000,0b010000,0b10000,0b11000] # byte registers
    gyro_config_vals = [250.0,500.0,1000.0,2000.0] # degrees/sec
    gyro_indx = 0
    bus.write_byte_data(MPU6050_ADDR, GYRO_CONFIG, int(gyro_config_sel[gyro_indx]))
    time.sleep(0.1)
    #Gravar no registro de configuração do Accel
    accel_config_sel = [0b00000,0b01000,0b10000,0b11000] # byte registers
    accel_config_vals = [2.0,4.0,8.0,16.0] # g (g = 9.81 m/s^2)
    accel_indx = 0
    bus.write_byte_data(MPU6050_ADDR, ACCEL_CONFIG, int(accel_config_sel[accel_indx]))
    time.sleep(0.1)
    # registro de interrupção (relacionado ao estouro de dados [FIFO])
    bus.write_byte_data(MPU6050_ADDR, INT_ENABLE, 1)
    time.sleep(0.1)
    return gyro_config_vals[gyro_indx],accel_config_vals[accel_indx]

def read_raw_bits(register):
    #ler valores de aceleração e giroscópio
    high = bus.read_byte_data(MPU6050_ADDR, register)
    low = bus.read_byte_data(MPU6050_ADDR, register+1)
    # combinado alto e baixo para valor de bit sem sinal
    value = ((high << 8) | low)

    # converter para +- valor
    if(value > 32768):
        value -= 65536
    return value
def mpu6050_conv():
    #bits de aceleração brutos
    acc_x = read_raw_bits(ACCEL_XOUT_H)
    acc_y = read_raw_bits(ACCEL_YOUT_H)
    acc_z = read_raw_bits(ACCEL_ZOUT_H)
    # bits temporários brutos
##    t_val = read_raw_bits(TEMP_OUT_H) # uncomment to read temp

    #pedaços brutos de giroscópio
    gyro_x = read_raw_bits(GYRO_XOUT_H)
    gyro_y = read_raw_bits(GYRO_YOUT_H)
    gyro_z = read_raw_bits(GYRO_ZOUT_H)
    #converter para aceleração em ge giroscópio dps
    a_x = (acc_x/(2.0**15.0))*accel_sens
    a_y = (acc_y/(2.0**15.0))*accel_sens
    a_z = (acc_z/(2.0**15.0))*accel_sens
    w_x = (gyro_x/(2.0**15.0))*gyro_sens
    w_y = (gyro_y/(2.0**15.0))*gyro_sens
    w_z = (gyro_z/(2.0**15.0))*gyro_sens
##    temp = ((t_val)/333.87)+21.0 # descomente e adicione abaixo em troca
    return a_x,a_y,a_z,w_x,w_y,w_z
def AK8963_start():
    bus.write_byte_data(AK8963_ADDR,AK8963_CNTL,0x00)
    time.sleep(0.1)
    AK8963_bit_res = 0b0001 # 0b0001 = 16-bit
    AK8963_samp_rate = 0b0110 # 0b0010 = 8 Hz, 0b0110 = 100 Hz
    AK8963_mode = (AK8963_bit_res <<4)+AK8963_samp_rate # bit conversion
    bus.write_byte_data(AK8963_ADDR,AK8963_CNTL,AK8963_mode)
    time.sleep(0.1)

def AK8963_reader(register):
    # ler os valores do magnetômetro
    low = bus.read_byte_data(AK8963_ADDR, register-1)
    high = bus.read_byte_data(AK8963_ADDR, register)
    # combinado alto e baixo para valor de bit sem sinal
    value = ((high << 8) | low)
    # converter para +- valor
    if(value > 32768):
        value -= 65536
    return value
def AK8963_conv():
    # bits de magnetômetro brutos
    loop_count = 0
    while 1:
        mag_x = AK8963_reader(HXH)
        mag_y = AK8963_reader(HYH)
        mag_z = AK8963_reader(HZH)
        # a próxima linha é necessária para AK8963
        if bin(bus.read_byte_data(AK8963_ADDR,AK8963_ST2))=='0b10000':
            break
        loop_count+=1

    #converter para aceleração em ge giroscópio dps
    m_x = (mag_x/(2.0**15.0))*mag_sens
    m_y = (mag_y/(2.0**15.0))*mag_sens
    m_z = (mag_z/(2.0**15.0))*mag_sens
    return m_x,m_y,m_z

# Registros MPU6050
MPU6050_ADDR = 0x68
PWR_MGMT_1   = 0x6B
SMPLRT_DIV   = 0x19
CONFIG       = 0x1A
GYRO_CONFIG  = 0x1B
ACCEL_CONFIG = 0x1C
INT_ENABLE   = 0x38
ACCEL_XOUT_H = 0x3B
ACCEL_YOUT_H = 0x3D
ACCEL_ZOUT_H = 0x3F
TEMP_OUT_H   = 0x41
GYRO_XOUT_H  = 0x43
GYRO_YOUT_H  = 0x45
GYRO_ZOUT_H  = 0x47
#Registros AK8963
AK8963_ADDR   = 0x0C
AK8963_ST1    = 0x02
HXH          = 0x04
HYH          = 0x06
HZH          = 0x08
AK8963_ST2   = 0x09
AK8963_CNTL  = 0x0A
mag_sens = 4900.0 # sensibilidade do magnetômetro: 4800 uT
# iniciar o driver I2C
bus = smbus.SMBus(1) # iniciar comunicação com ônibus i2c
gyro_sens,accel_sens = MPU6050_start() # instantiate gyro/accel
AK8963_start() # magnetômetro instanciar
# MPU6050 9-DoF Example Printout
from mpu9250_i2c import *
time.sleep(1) # delay necessary to allow mpu9250 to settle
print('recording data')
while 1:
    try:
        ax,ay,az,wx,wy,wz = mpu6050_conv() # read and convert mpu6050 data
        mx,my,mz = AK8963_conv() # read and convert AK8963 magnetometer data
    except:
        continue

    print('{}'.format('-'*30))
    print('accel [g]: x = {0:2.2f}, y = {1:2.2f}, z {2:2.2f}= '.format(ax,ay,az))
    print('gyro [dps]:  x = {0:2.2f}, y = {1:2.2f}, z = {2:2.2f}'.format(wx,wy,wz))
    print('mag [uT]:   x = {0:2.2f}, y = {1:2.2f}, z = {2:2.2f}'.format(mx,my,mz))
    print('{}'.format('-'*30))
    time.sleep(1)

Armazenamento dos dados

Agora que temos o programa que coleta as informações do acelerometro, podemos preparar o padrão de armazenamento, criando estruturas em mysql que armazenam os dados, e que posteriormente, sejam analisadas.

maurinsoft.com.br