The Developer Conference – 2014

The Developer Conference – 2014.

Participe do evento “The Developer’s Conference”, o evento conta com diversos temas muito interessantes englobando diversos assuntos sobre as tecnologias mais atuais do mercado, muitos desses temas são mantidos pela comunidade de software livre, isso garante que os assuntos terão muito conteúdo.
Evento TDC2014
Confira a programação do evento: TDC2014

Qualquer dúvida: Twitter

Publicado em Java | Publicar um comentário

Programação Humanoide C++

Estamos iniciando na católica um estudo em programação para robótica inteligente com o controle de robôs humanoides, nossos primeiros testes de códigos estão disponíveis no GitHub. Códigos de controle serial Java com arduíno: https://github.com/schmittjoaopedro/Java/tree/master/Release-Java-Serial Códigos de leitura C++ para Arduíno: https://github.com/schmittjoaopedro/Framework-Read-Serial-Arduino/tree/master/Controler_Serial_Commands Esses códigos seguem padrões de Orientação a Objetos (OO) e oferecem maior usabilidade, extensibilidade e manutenção das estruturas, por exemplo em nossas pesquisas achamos poucas pessoas que programa Orientação a Objetos em C++, de 500 pesquisas talvez umas 3 possuíam códigos com enfoque nesse padrão, então estamos propondo além de uma inteligência de controle para o humanóide um novo padrão de programação C++ para Arduíno.

Publicado em Arduino, Java, Linguagem C | Etiquetas , , , , , , , , , , , | Publicar um comentário

ROBÔS COLABORATIVOS COM COMUNICAÇÃO

Com os crescentes avanços tecnológicos de sistemas distribuídos autônomos, uma área que tem ganhado cada vez mais relevância no mercado é a robótica. As linhas de produção principalmente tem aderido muito bem esta ideia de utilizar máquinas autônomas para tarefas repetitivas, porém está surgindo um novo quesito em tecnologias autônomas inteligentes. Nosso projeto teve como foco desenvolver um protótipo robótico rádio controlado, com um sistema de segurança contra colisões em obstáculos, assim sendo ao estarmos percorrendo um trajeto com o robô e entrássemos em rota de colisão o próprio equipamento teria a inteligência de parar antes da colisão, observar ambos os lados e decidir perante as medidas qual a melhor rota para tornar-se e posicionar-se sugerindo ao controlador seguir por ela. Iniciamos as pesquisas com estudos nas principais áreas de engenharia como elétrica, mecânica e programação. Focamos mais na parte de elétrica, pois precisávamos ter uma base fortificada para darmos os primeiros passos na montagem dos circuitos iniciais, entre estes estudos de elétrica e de programação em linguagem “C/C++” mesclamos a tecnologia Arduíno que teve o papel principal em nosso desenvolvimento. Utilizamos conceitos de mecânica para desenvolver uma carcaça que comportasse nossos circuitos criados e oferecesse mobilidade. Depois de consolidado os conhecimentos, criado os primeiros circuitos e a carcaça mecânica focamos na refinação e aperfeiçoamento da inteligência do algoritmo do controlador do robô e do próprio robô. Terminado um protótipo funcional do primeiro robô partimos para a criação do segundo para termos uma comunicação multiagente.

Palavras-Chaves: Robótica IA, Redes, Comunicação, Multiagente.

1.  INTRODUÇÃO 

Com o crescente aumento de sistemas e ferramentas autônomas no mercado de trabalho para linhas de produção e inteligência multiagente, uma área que está cada vez mais presente em nosso dia-a-dia tem sido a robótica. Visamos um futuro que sistemas de inteligência artificial reativa e cognitiva terão grande participação em pesquisas tecnológicas e aplicações do mundo real.

            Dessa maneira definimos a proposta de desenvolver um robô controlado via rádio frequência por um controlador, aonde nosso protótipo robótico tem capacidade de detecção de obstáculos físicos e inteligência autônoma para evitar colisões fazendo uma varredura em busca do melhor caminho para desviar o objeto e então se mover de forma a direcionar o controlador de qual caminho ele deveria seguir para evitar o obstáculo.

2. FUNDAMENTOS ROBÓTICOS

A robótica utiliza-se da junção de praticamente todas as áreas das engenharias, tanto mecânicas, elétricas quanto sistemas de informação. É um tema muito abrangente, pois já há robótica em muitas áreas de estudos. Temos robótica em todos os segmentos industriais, voltado mais para tarefas mecânicas e repetitivas realizadas por pessoas comuns, como em linhas de montagem é muito comum ver robôs realizando essas tarefas. A robótica em si necessita de sistemas de engenharia para desenvolvimento de circuitos elétricos avançados, processos mecânicos precisos e inteligência própria para tomada de decisões, o projeto que descrevemos neste artigo utilizou muitos fundamentos de engenharia mecânica e elétrica, porém o principal foco foi o desenvolvimento de inteligência para um sistema robótico capaz de tomar decisões autonomamente, definimos como robótica avançada não somente como um processo que imite os movimentos humanos, mas que, além disso, possua consciência e inteligência para tomar melhores decisões perante adversidades do ambiente. Segundo pesquisas realizadas na comunidade Google, vimos notícias de que o Google conseguiu desenvolver um sistema robótico inteligente, aonde esse sistema desenvolvido pelo conseguiu avaliar milhares de vídeos aleatórios de gatos e não comparar a um espécime já catalogado por nós, mas autonomamente desenvolver um padrão para determinada aparência comum dos felinos, e criar seu próprio catálogo referente aquele espécime padronizado. Resumindo além das engenharias mecânicas e elétricas para desenvolvimento, precisão e redução de circuitos e sistemas robóticos se têm uma área que tem ganhado sua importância nesse novo universo é a informática com intuito de desenvolver a inteligência de sistemas robóticos.

3. PESQUISA DE PLACAS CONTROLADORAS

Estudou-se a tecnologia Arduíno como foco do desenvolvimento deste projeto pelo fato do Arduíno ser uma plataforma com suporte a linguagem que determinado sistema deverá executar, assim ele serviu como facilitador para controlar a iteração com diversos equipamentos eletrônicos. Dentre esses estudos se resolveu utilizar da plataforma Arduíno Uno R3, por se apresentar com o melhor custo e benefício para nossa aplicação. Aprofundando o conhecimento sobre o Arduíno ele oferece uma plataforma para desenvolvimento e compilação de programas, neste cenário podemos utilizar da linguagem C++ trabalhando até mesmo programação orientada a objetos. Para compilar o código para o Arduíno é muito simples, utilizamos de uma porta USB aonde o próprio IDE do Arduíno compila o código e faz upload para a placa. Abaixo segue uma imagem demostrando a placa utilizada em nosso projeto.

 arduino

Figura 1 – Placa Arduíno Uno R3

4. DESENVOLVIMENTO

Iniciamos as pesquisas focando na área de eletrônica para podermos criar circuitos inicias que atendessem a nossa necessidade para o desenvolvimento de um robô controlado com inteligência anticolisão. Foram desenvolvidos vários tipos de circuitos diferentes e programadas lógicas distintas para cada circuito isoladamente, fizemos este processo para emular técnicas e observar seus diferentes comportamentos.

A principal fase de desenvolvimento e que obtivemos maiores resultados foi o desenvolvimento de um sistema para controle de motores utilizando circuitos integrados de ponte H (L293B) e contadores binários (74HC595N). A imagem abaixo demonstra o funcionamento deste circuito, nosso maior avanço neste circuito foi usarmos somente três portas do Arduíno para conseguirmos controlar quatro motores independentemente, caso fizéssemos do modo tradicional precisaríamos de oito portas.

 motorcomshield

Figura 2 – Circuito de Controle do Motor

Além deste principal circuito para o controle dos motores, utilizamos também alguns circuitos mais simples para controle do rádio frequência que fora desenvolvido um controle para emissão dos sinais e adicionado ao robô um rádio como receptor interpretador e conversor dos dados recebidos para controle dos motores, além disso, foi adicionado um sensor ultrassônico sobre um servo motor de modo a criarmos uma espécie de cabeça giratória que consiga detectar obstáculos. Em nosso protótipo final temos a imagem abaixo representando os robôs criados.

robos

Figura 3 – Robôs colaborativos com comunicação sem fio.

A principal inteligência do robô criada para detecção e desvio de obstáculos além dos comandos para torna-lo controlado ou autônomo são representados no fluxograma a seguir, vale ressaltar que isto é somente o método principal de seu funcionamento, temos os métodos que servem como serviço para assessoramento do robô que pela sua devida extensão não pudemos adicionar aqui.

fluxo

Figura 4 – Fluxograma da inteligência do robô.

 5. CONSIDERAÇÕES FINAIS 

Com o presente projeto evidenciamos a importância da inteligência artificial no âmbito de robótica, com esse projeto propusemos apresentar equipamentos rádio controlados que tivessem domínio sobre análise do ambiente e inteligência para evitar possíveis colisões, essa tecnologia já se encontra em diversos automóveis modernos, porém com outras formas de inteligência autônoma.

Foi preciso entender o funcionamento da plataforma Arduíno e desenvolver uma base sólida sobre eletrônica para a construção dos circuitos, podemos observar que a complexidade da criação do nosso robô foi maior referente à montagem elétrica pelo fato de possuirmos pouco conhecimento, porém conseguimos apresentar uma simulação de um robô inteligente contra colisões. Além disso, concluímos que muitos componentes puderam ser reutilizados de materiais sucateados, aonde reaproveitamos motores, botões e fiação.

Para trabalhos futuros propomos evoluir nos algoritmos de inteligência para robótica e evoluirmos no processo mecânico com o desenvolvimento de um robô humanoide. Visamos à construção do humanoide utilizando uma câmera para representar a visão do robô e um sistema autônomo mais avançado.

Publicado por João Pedro Schmitt – 23/07/2013

Publicado em Arduino, Linguagem C | Etiquetas , , , , , , , , , , , , , , , , , , , | Publicar um comentário

Algoritmos de Grafo

Olá,

Grafos são sistemas de interconexões que trabalham com vértices que são os pontos de partida e chegada e arestas que são propriamente o caminho entre os vértices, podemos fazer uma analogia de comparação de grafos com o sistema neural humano.

Atualmente os grafos tem grande abrangência na área tecnológica pois muitos sistemas distribuídos fazem uso dos mesmos. Exemplo os GPS, Mapas e a própria rede de internet global trabalha em cima de grafos.

Em uma rede global de internet os grafos são representados da seguinte maneira, um roteador representa um vértice e qualidade do link de transporte entre dois roteadores é a aresta do grafo, assim, fazendo uma análise temos um grafo ponderado, que trabalha a ideia de calcular o melhor caminho até determinado roteador, neste exemplo de grafo entre roteadores os links apresentam latência e quantidade de banda que ponderam a distância entre dois roteadores, criando assim uma teia de caminhos que podemos usar para calcular rotas.

Abaixo segue projeto de aplicação feita no NetBeans IDE demonstrando a criação de um grafo e o cálculo de menor caminho, neste projeto são usados conceitos de busca em largura e o algoritmos dijkstra para calcular menor caminho.

Para baixar o projeto com algoritmo clique aqui

Para baixar o projeto com algoritmo aplicativo gerador clique aqui.

Segue abaixo implementação parcial algoritmos dijkstra pela Ana Fernanda Gomes:

static void dijkstra(listaadj Adj[], int tam, int v) {
int i, w;
int C[] = new int[tam];
int tamC = 0;
lista = new ListaPriori(tam);
dist[v] = 0;
lista.inserir(v, dist);
for (i = 1; i <= tam; i++) {
if (i != v) {
dist[i] = Integer.MAX_VALUE;
pai[i] = 0;
lista.inserir(i, dist);
}
}
while (lista.tam != 0) {
w = lista.remover(dist);
C[tamC] = w;
tamC++;
 vertice x = Adj[w].listav;
while (x != null) {
relax(w, x.num, x.peso);
x = x.prox;
}
lista.constroiheap(dist);
}
}
static void relax(int u, int v, int peso) {
if (dist[v] > dist[u] + peso) {
dist[v] = dist[u] + peso;
pai[v] = u;
}
}

 

Autor: João Pedro Schmitt 27/06/2013

Publicado em Java | Etiquetas , , , , , , , , , , , , , , , , , , , , , , , | Publicar um comentário

Algoritmos de Ordenação em Java

Atualmente com a acensão da linguagem Java, muitos algoritmos feitos em linguagens legadas tem deixado de ser usados e essas tecnologias tem sido atualizadas para sistemas orientado a objetos.  Neste tópico vou buscar apresentar os principais tipos de ordenação de dados e apresentar seu respectivos algoritmos em Java, para quem preferir testar esses algoritmos estou disponibilizando o link para download da aplicação que faz a ordenação de algoritmos em java em tempo real usando threads, aonde você pode tirar informações relevantes como número de trocas, comparações e avaliar a sistemática de ordenação para cada tipo de dado. Para fazer o download da aplicação clique aqui. Caso você não tenha conta basta acessar este outro link: https://mega.co.nz/#!Dcc2nD6Q!TwXt8GxMDrV53PzL651OY0JVvflyq8eQb_2OwplQT70

Após baixada aplicação basta extrai-la e executar o executável “OrdenadorDeAlgoritmos”, segue abaixo uma imagem de como utilizar a aplicação, desse modo facilitando o entendimento, esse programa gera valores aleatórios para ordenação, ele somente é demonstrativo não pode ser aplicado necessariamente a uma aplicação.

programaOrdenador

Alguns algoritmos de ordenação em java, esses algoritmos se encontram na integra da mesma forma que foram utilizados no programa citado acima, neste modelo somente estarei passando o método que executa a ordenação, em todos os algoritmos o getOrdenaveis() retorna o array que está a ser ordenado.

Bubble Sort 

O método bubble sort trabalha comparando todos os valores dos vetores, por exemplo o primeiro com o segundo depois com o terceiro, e assim por diante até o último valor, depois ele inicia o mesmo processo só que uma posição a mais comparando o segundo com o primeiro, depois com o terceiro. Esse processo de comparação passa por uma condição que se um valor for menor que o outro eles trocam de posição. O algoritmo abaixo descreve esse processo.

public synchronized void ordenar() {
int troca = 1;
int n = 0;
setTempoInicial();
while (n < getOrdenaveis().length && troca == 1) {
troca = 0;
MostraStatusLoop();
for (int i = 0; i < getOrdenaveis().length – 1; i++) {
setNumeroComparacoes();
if (getOrdenaveis()[i] > getOrdenaveis()[i + 1]) {
setNumeroTrocas();
troca = 1;
trocarPosicaoVetores(i, (i + 1));
}
}
atualizarPainel();
n++;
try{
sleep(getTimeSleepValue());
}catch(InterruptedException er){
JOptionPane.showMessageDialog(null, “O Aplicativo parou inesperadamente”);
}
setTempoFinal();
}
}

Insertion Sort

Esse algoritmo se baseia no processe de inserção, dessa forma quando ele recebe um novo valor ele sempre vai o alocar na posição que corresponde a sua faixa de ordenação.

public synchronized void ordenar() {
setTempoInicial();
for (posicao = 1; posicao < getOrdenaveis().length; posicao++) {
MostraStatusLoop();
eleito = getOrdenaveis()[posicao];
aux = posicao – 1;
setNumeroComparacoes();
while (aux >= 0 && getOrdenaveis()[aux] > eleito) {
setNumeroTrocas();
getOrdenaveis()[aux + 1] = getOrdenaveis()[aux];
aux–;
}
getOrdenaveis()[aux + 1] = eleito;
atualizarPainel();
setTempoFinal();
try{
sleep(getTimeSleepValue());
}catch(InterruptedException e){
JOptionPane.showMessageDialog(null, “Aplicativo encerrou inesperadamente”);
}
}
}

Merge Sort

O vetor vai sendo dividido em blocos com a metade do inicial, no final quando sobra um único valor ou dois valores esses valores são comparados pra todos os blocos que foram divididos, depois de feitos esse processo os blocos são intercalados de forma ordenada.

public void merge(int vetor[], int inicio, int fim, int cont){
int meio;
cont++;
if(inicio < fim){
meio = (inicio + fim) /2;
merge(vetor, inicio, meio,cont);
merge(vetor, meio + 1, fim,cont);
intercalar(vetor, inicio, meio, fim);
}
MostraStatusLoop();
atualizarPainel();
try{
sleep(getTimeSleepValue());
}catch(InterruptedException er){
JOptionPane.showMessageDialog(null, “O Aplicativo Parou Inesperadamente”);
}
}
public void intercalar(int vetor[], int inicio, int meio, int fim){
int posLivre = inicio;
int inicioVetor1= inicio;
int inicioVetor2 = meio + 1;
int aux[] = new int[vetor.length];
while(inicioVetor1 <= meio && inicioVetor2 <= fim){
setNumeroComparacoes();
if(vetor[inicioVetor1] <= vetor[inicioVetor2]){
setNumeroTrocas();
aux[posLivre] = vetor[inicioVetor1];
inicioVetor1++;
}else{
setNumeroTrocas();
aux[posLivre] = vetor[inicioVetor2];
inicioVetor2++;
}
posLivre++;
}
for (int i = inicioVetor1; i <= meio; i++) {
setNumeroTrocas();
aux[posLivre] = vetor[i];
posLivre++;
}
for (int i = inicioVetor2; i <= fim; i++) {
setNumeroTrocas();
aux[posLivre] = vetor[i];
posLivre++;
}
for (int i = inicio; i <= fim; i++) {
vetor[i] = aux[i];
}
}

Quick Sort (o mais eficiente)

Faz um processo similar ao merge sort, aonde a medida que o vetor vai sendo ordenado vão sendo realizadas partições recursivas em torno de ganhar desempenho.

public synchronized void quickSort(int vet[], int ini, int fim, int cont) {
int meio;
if (ini < fim) {
meio = partition(vet, ini, fim);
quickSort(vet, ini, meio, cont);
quickSort(vet, meio + 1, fim, cont);
}
MostraStatusLoop();
atualizarPainel();
try{
sleep(getTimeSleepValue());
}catch(InterruptedException er){
JOptionPane.showMessageDialog(null, “O Aplicativo Parou Inesperadamente”);
}
}
public int partition(int vet[], int ini, int fim) {
int pivo, topo, i;
pivo = vet[ini];
topo = ini;
for (i = ini + 1; i <= fim; i++) {
setNumeroComparacoes();
if (vet[i] < pivo) {
setNumeroTrocas();
vet[topo] = vet[i];
vet[i] = vet[topo + 1];
topo++;
}
}
vet[topo] = pivo;
return topo;
}

Selection Sort

Neste método o vetor seleciona sequencialmente os vetores da ordenação e localiza um próximo que seja o menor ou maior (conforme o tipo de ordenação crescente ou decrescente) então esse valor é comparado com o valor selecionado no inicio, se a condição é verdadeira a posição dos valores são trocadas ordenando o algoritmo.

public synchronized void ordenar() {
setTempoInicial();
for (posicao = 0; posicao < getOrdenaveis().length – 1; posicao++) {
MostraStatusLoop();
eleito = getOrdenaveis()[posicao];
menor = getOrdenaveis()[posicao + 1];
pos = posicao + 1;
for (int j = posicao + 2; j < getOrdenaveis().length; j++) {
setNumeroComparacoes();
if (getOrdenaveis()[j] < menor) {
menor = getOrdenaveis()[j];
pos = j;
}
}
if (menor < eleito) {
setNumeroTrocas();
getOrdenaveis()[posicao] = getOrdenaveis()[pos];
getOrdenaveis()[pos] = eleito;
}
atualizarPainel();
try {
sleep(getTimeSleepValue());
} catch (InterruptedException er) {
JOptionPane.showMessageDialog(null, “Aplicativo encerrado inesperadamente”);
}
}
setTempoFinal();
}

Autor: João Pedro Schmitt – 05/2013

Publicado em Java | Etiquetas , , , , , , , , , , | 1 Comentário

Software Financeiro (Calculadora Financiamento) para Android

Desenvolvimento de aplicativo para cálculos financeiros como financiamento price e calculo salarial desenvolvido pelos acadêmicos: João Pedro Schmitt, Gabriel Burno Meinchein e Lucas Nort, na faculdade Católica campus de Jaraguá do Sul. Esse aplicativo busca viabilizar e facilitar cálculos dinâmicos comuns constantemente utilizados.

Para instalar basta baixar o aplicativo, copiar para o celular e confiar o software no Android para instalação.

Link para download: Clique aqui.

Para maiores dúvidas acesse: http://android.orionhub.org:8080/index.html

Algumas imagens:

Ícone após instalação:

tela12

Tela principal para cálculo do financiamento price:

tela4

Menu principal da aplicação:
Imagem1

Autor: João Pedro Schmitt

Publicado em Android, Java | Etiquetas , , , , , | Publicar um comentário

Pato Pow

Game desenvolvido nas aulas de laboratório de informática pela faculdade Católica de Jaraguá do Sul. Game PatoPow, apenas basta baixar descompactar e executar o arquivo PatoPow.

Link para download: Clique aqui para baixar.

patoPow

 

Autor: João Pedro Schmitt

Publicado em Java | Publicar um comentário