Versão em desenvolvimento do Arduino Mega

Atualmente, o firmware do robotinics esta com aproximadamente 2 anos, desde sua ultima atualização.

Durante este período, vários recursos e dispositivos surgiram.

Após este longo período, o projeto do firmware esta sofrendo uma repaginada na versão em desenvolvimento do firmware do Arduino Mega – Robotinics 1.4 Betha.


Esta versão tem a responsabilidade de controlar os devices (dispositivos do robô), tais como display TFT. Criando uma interface amigável, para que o raspberry realizar os comandos de alto nível e deixar todo o controle do hardware para o arduino.

Esta versão contará com suporte ao Nextion, e correções das bibliotecas do arduino, já que algumas libs foram modificadas pelos fabricantes.

Esta versão, 1.4 Betha, ainda esta em desenvolvimento, porem pode ser baixada no link.

Para quem desejar utilizar uma versão mais estável, recomendamos a versão 1.3.

Evolução do firmware

Todo projeto, passa por mudanças. Devido a atualizações tecnológicas e evolutivas naturais dentro de uma linha de aprendizado pessoal.

Essa mudança é justificada, pois as pessoas e processos são adaptados pois  ganhamos maior conhecimento sobre técnicas e ferramentas, durante o ciclo do desenvolvimento do produto.

Tambem, avaliamos durante esta jornada, quais os objetivos que foram assumidos, e quais devemos conquistar nas próximas etapas.

Podemos ver, que estamos refazendo as ligações, e código, revalidando o hardware.

Criando e retirando periféricos, tais como display VGA touch screen.

Esta mudança, simplifica a comunicação, melhora várias técnicas do projeto.

Sem falar, que agrega novas características, criando uma interface amigável, no próprio robô.

Permitindo monitoramento e leitura de seus parâmetros, diretamente na tela, com simplicidade e rapidez de desenvolvimento.

Neste próximo exemplo, vemos uma interface, de informação de proximidade do ultrassom, que podemos identificar.

Nela, são passados, a distancia em centímetros, do objeto detectado.

Com a adição deste recurso, fica mais simples, testes e medições, visuais dos sensores.

Podemos ver a tela inicial do Nextion, a navegação touch.

Serão monitorados, todos os devices, tais como:

  • sensores de proximidade
  • Sensor de corrente consumida
  • Sensor de voltagem
  • Sensor de Gás (Quando disponível)
  • Internet
  • Reconhecimento de Imagem
  • Reconhecimento de Voz

Entre outros.

 

Processamento de comandos

Na imagem abaixo, podemos verificar, que o arduino, estabelece um sistema de comunicação, entre o raspberry.

Permitindo que ambos troquem informações, como execução de comandos, recebimento de valores.

Esta troca, também será estendida.

Melhorando os comandos, expandindo, e tornando o código mais produtivo.

Nos próximos posts, estaremos abordando como serão realizados e quais serão estes comandos.

As técnicas aqui abordadas, podem ser expandidas para qualquer outro dispositivo, não somente um robô.

Ficando desta forma, como base para o desenvolvimento de solução IoT, que pode tambem ser utilizada.

 

Script de Detecção de Faces para Robô

Um projeto robótico precisa enxergar objetos, a fim de tomada de ações.

O Robotinics não pode fugir deste tópico.

A seguir, iremos iniciar a abordagem deste projeto.

O ROBOTINICS utiliza uma abordagem não linear, para processamento de imagens.

Inicialmente, utilizamos o motion, que cria um serviço de stream de video.

A partir deste stream de video, identificamos as imagens contendo movimentação, e a partir da movimentação, disparamos scripts que interpretam a imagem.

Existem um numero infinito de analises possíveis, porem abordaremos aqui apenas o básico.

O Processamento da imagem, dispara um script chamado:

analisa_img.sh

Este shell script pode ser visto, conforme exemplo abaixo:

#!/bin/bash


quebrar() {
local filepath="$1"
local filename=$(basename "$filepath")
local ext=$(echo "$filename"| awk -F '.' '{ if (NF==2) {print $NF} else if ( NF>2) {print $(NF-1)"."$NF} }')
local dir=$(echo "$filepath" | awk -F '/' '{ print substr($0, 0 , length($0)-length($NF)-1) }')
echo -e "$dir""\t""$filename""\t""$ext"
}

ret="$(quebrar "$1")"
echo "$diretorio: " "$(echo "$ret" | cut -f1)"
diretorio="$(echo "$ret"|cut -f1)"
filename="$(echo "$ret"| cut -f2)"
somentefilename="$(echo "$filename"| cut -d. -f1)"
extensao="$(echo "$filename"| cut -d. -f2)"
novoarquivo="$(echo "$1"| cut -d. -f1)"
novoarquivo="$(echo "$novoarquivo"".mp4")"

#echo "Desmembramento do arquivo"
#echo $diretorio
#echo $somentefilename
#echo $extensao
#echo $filename
echo $novoarquivo


#ffmpeg -i $1 -c:v libx264 -preset ultrafast $novoarquivo

python /projetos/python/cv/load.py $novoarquivo


#rm -f $1

O código em destaque,

python /projetos/python/cv/load.py $novoarquivo

chama o load.py, que inicia o processamento da imagem, identificando na imagem, onde se encontra a face.

Podemos chamar, assim como neste exemplo, chamadas, para outras detecções, como olhos, bocas, objetos diversos.

As informações processadas, são armazenadas em tabelas do banco de dados.

O Código escrito em python

load.py

import sys
import numpy as np
import cv2
import MySQLdb
import pickle
import numpy as np
#import face_recognition

def conexao():
Banco="banco"
User="usuario"
Passwrd="senha"
Host="local"
resultado = 0

try:
resultado = MySQLdb.connect(db=Banco,user=User, passwd=Passwrd, host=Host)
except:
print("Erro ao conectar no Banco de dados")
resultado = -1
return resultado

def imcrop(img, bbox):
x1,y1,x2,y2 = bbox
if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
img, x1, x2, y1, y2 = pad_img_to_fit_bbox(img, x1, x2, y1, y2)
return img[y1:y2, x1:x2, :]

def pad_img_to_fit_bbox(img, x1, x2, y1, y2):
img = np.pad(img, ((np.abs(np.minimum(0, y1)), np.maximum(y2 - img.shape[0], 0)),
(np.abs(np.minimum(0, x1)), np.maximum(x2 - img.shape[1], 0)), (0,0)), mode="constant")
y1 += np.abs(np.minimum(0, y1))
y2 += np.abs(np.minimum(0, y1))
x1 += np.abs(np.minimum(0, x1))
x2 += np.abs(np.minimum(0, x1))
return img, x1, x2, y1, y2


def GravaReg(arquivo,x,y,a,h):
con = conexao()
cursor = con.cursor()
sql= "insert into eventoCam (arquivo,x,y,a,h) values ('%s',%d,%d,%d,%d)" %(arquivo,x,y,a,h)
print(sql)
try:
cursor.execute(sql)
con.commit()
print("Registro Gravado")
except MySQLdb as erro:
print("Erro ao Executar SQL", erro)

#Pega o nome do arquivo a ser analisado
Arquivo = sys.argv[1]

# load an color image in grayscale
img = cv2.imread(Arquivo)
print("Carregado:%s",Arquivo)

classificador = cv2.CascadeClassifier("/projetos/python/cv/face.xml")
#eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')


#imagemCinza = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
imagemCinza = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)

#facesDetectadas = classificador.detectMultiScale(imagemCinza, scaleFactor=1.5, minSize=(100,100))
facesDetectadas = classificador.detectMultiScale(imagemCinza, 1.3, 5)
for (x1,y1,x2, y2 ) in facesDetectadas:
print("Face:",x1,y1)
GravaReg(Arquivo,x1,y1,x2,y2)
imcrop(img,bbox)
bbox.imwrite('face.png',roi_color)

cv2.destroyAllWindows()
print("Finalizou")

Para realizar o processamento deste projeto, primeiro é necessário configurar  o banco de dados.

def conexao():
Banco="banco"
User="usuario"
Passwrd="senha"
Host="local"
resultado = 0

Escrevendo o banco de dados (robotinicsdb), usuario e senha do banco, não esquecendo também do local.

A tabela eventoCam, armazena o evento da imagem processado.

 

 

srvFala – Instalando o servidor de voz

O servidor de voz é constituído de 5 partes.

  • Servidor de conexão de Voz (Linux/C)
  • Tabela de dados para armazenamento de comandos e histórico (Mysql)
  • Cliente de conexão e simulação de sintetização (Windows/Lazarus)
  • Script de sintetização de voz
  • espeak (pacote de sintetização)

Estaremos abordando a instalação do Servidor

Instalação do Servidor

O Arquivo do Servidor esta localizado no seguinte link:

Baixe os arquivos e descompacte em uma pasta do seu linux.

mysql

O servidor necessita de informações de tabelas, para tal rode os scripts do banco.

Edite o arquivo Makefile

USER=usuario
PASSWORD="senha"

all: drop create tables procedures samples

create:
mysql -u $(USER) -p$(PASSWORD) < robotinicsdb.sql
drop:
mysql -u $(USER) -p$(PASSWORD) < dropdb.sql
tables:
mysql -u $(USER) -p$(PASSWORD) < users.sql
mysql -u $(USER) -p$(PASSWORD) < security.sql
mysql -u $(USER) -p$(PASSWORD) < falas.sql
mysql -u $(USER) -p$(PASSWORD) < frases.sql
procedures:

samples:
mysql -u $(USER) -p$(PASSWORD) < i_users.sql
mysql -u $(USER) -p$(PASSWORD) < i_frases.sql

Substitua o usuário e senha pelo seu respectivo usuário e senha do banco de dados mysql.

No terminal da console execute o comando

make all

Se o banco foi criado corretamente, deve existir um banco robotinicsdb em seu mysql.

Para maiores informações, leia o livro do robotinics.

 

srvFala

Esta aplicação roda em qualquer linux (X86/ARM)

Edite o arquivo fala1.c

int socket_desc , client_sock , c , read_size;
struct sockaddr_in server , client;
char client_message[2000];
char buffer[2000];

MYSQL mycon; //Ponteiro de conexao Mysql

//Parametros da Conexão com banco de dados
char localdb[80] = "database";
char userdb[80] = "usuario";
char passdb[80] = "password";
char aliasdb[80] = "database";

Substitua o database, usuario, password, e aliasdb, pelos respectivos valores do banco de dados.

O database padrão é robotinicsdb.

Rode os seguintes comandos:

make compile

make install

Existem dependências do software, tais como instalação do mysql e ambiente do compilador. Para maiores informações sobre a instalação destas dependências, leia o livro do robô.

Execute o servidor através do comando:

./srvFala

 

 

Procedimentos do cliente de fala

ToolsFalar

Entre neste procedimento e verifique os procedimentos para sua instalação.

espeak

Para instalar o espeak, verifique o procedimento no livro, conforme o link:

Livro gratuito

Controle do Robo por Bluetooth

O programa Bluetooth, permite controlar o robô por Bluetooth.

O Instalador esta disponível pelo link:

Bluetooth

Telas do Bluetooth

Tela principal do Programa

Coleta de Informações dos sensores

Controle de Movimento

Controle dos braços

Setup e configuração da porta do bluetooth

Neste vídeo utilizo o controle por bluetooth, que é semelhante ao TCP.

 

Telas do Nextion

Screen Shot das Telas do Nextion

Tela inicial do TFT

Menu principal do Nextion

Menus de Ultrassom, Internet e camera

Opções de GPS, Bluetooth e RF ou RFID

Sistema de medição de nível de bateria

Controle de Bluetooth

Controle de Movimento do Braço Robótico

Sistema de Reconhecimento Facial

Sistema de leitura de GPS

Identificação do IP e Internet

Painel de Reconhecimento de Vóz

RFID ou RF da interface

Controle e monitoramento de Distância de Objetos

Fonte da Tela Nextion