Curso de Robótica com ênfase na plataforma Arduino

Olá pessoal!

Hoje o objetivo do post não é desenvolver projetos utilizando Arduino, mas sim divulgar um curso da Insituição de ensino onde trabalho. O site da Instituição pode ser acessado clicando no link FEMA.

Esse curso será ministrado por mim e terá inicio no dia 18/08/2012  com um total de 12 aulas. Cada aula terá duração de 4 horas e serão dadas aos sábados a tarde em função dos horários de trabalho e estudos.

Abaixo segue um folder de divulgação…

Para maiores informações: www.fema.com.br

por ferpinheiro Postado em Arduino

Arduino e display de 7 segmentos com 4 digitos

Olá galera. A dica de hoje é como utilizar um display de 7 segmentos com 4 dígitos, com esse display é possível fazer vários projetos como relógios, visualização de dados de sensores de temperatura, distancia, é possível ainda criar cronômetros entre outros.

Esse display foi um “presente” que ganhei de um amigo certa vez… Como ele iria joga-lo fora e eu pensei que algum dia poderia ser útil ter um desses, pedi a ele que me presenteasse (risos)…

Enfim, acabei guardando tão bem o presente que demorei a encontra-lo, mas como naquele ditado em que diz: Quem procura acha! Acabei encontrando-o e resolvi criar esse tutorial.

Primeiramente devemos recorrer ao seu datasheet que pode ser encontrado AQUI, ou ainda ver a figura abaixo:

Como voces podem ver os anodos são os pinos 12, 9, 8 e 6. Os demais pinos são para os segmentos: A pino 11, B pino 7, C pino 4, D pino 2, E pino 1, F pino 10, G pino 5 e DP (pontos) pino 3.

Sabendo disso, segue um código simples de como mostrar os números:

/*
# Autor: Fernando Krein Pinheiro
# Data: 10/07/2012
# Linguagem: C/C++

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

=================================*/

#define DIGITO_1 9 //Anodo 12
#define DIGITO_2 10 //Anodo 9
#define DIGITO_3 11 // Anodo 8
#define DIGITO_4 12 //Anodo 6

#define SEGMENTO_A 2 // display 11
#define SEGMENTO_B 3 // dysplay 7
#define SEGMENTO_C 4 // display 4
#define SEGMENTO_D 5 // display 2
#define SEGMENTO_E 6 // display 1
#define SEGMENTO_F 7 // display 10
#define SEGMENTO_G 8 // display 5
#define PONTO 13 // display 3

#define ON  HIGH
#define OFF LOW

void setup()
{

  pinMode(DIGITO_1, OUTPUT);
  pinMode(DIGITO_2, OUTPUT);
  pinMode(DIGITO_3, OUTPUT);
  pinMode(DIGITO_4, OUTPUT);
  pinMode(PONTO, OUTPUT);

  pinMode(SEGMENTO_A, OUTPUT);
  pinMode(SEGMENTO_B, OUTPUT);
  pinMode(SEGMENTO_C, OUTPUT);
  pinMode(SEGMENTO_D, OUTPUT);
  pinMode(SEGMENTO_E, OUTPUT);
  pinMode(SEGMENTO_F, OUTPUT);
  pinMode(SEGMENTO_G, OUTPUT);

}

void loop()
{
   digitalWrite(DIGITO_1, HIGH);
   digitalWrite(DIGITO_2, HIGH);
   digitalWrite(DIGITO_3, HIGH);
   digitalWrite(DIGITO_4, HIGH);
   digitalWrite(PONTO, HIGH);

   ZERO();
   delay(1000);
   UM();
   delay(1000);
   DOIS();
   delay(1000);
   TRES();
   delay(1000);
   QUATRO();
   delay(1000);
   CINCO();
   delay(1000);
   SEIS();
   delay(1000);
   SETE();
   delay(1000);
   OITO();
   delay(1000);
   NOVE();
   delay(1000);

}
void ZERO()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, LOW);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, HIGH);
}
void UM()
{
   digitalWrite(SEGMENTO_A, HIGH);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, HIGH);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, HIGH);
   digitalWrite(SEGMENTO_G, HIGH);
}
void DOIS()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, HIGH);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, LOW);
   digitalWrite(SEGMENTO_F, HIGH);
   digitalWrite(SEGMENTO_G, LOW);

}
void TRES()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, HIGH);
   digitalWrite(SEGMENTO_G, LOW);
}
void QUATRO()
{
   digitalWrite(SEGMENTO_A, HIGH);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, HIGH);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, LOW);

}
void CINCO()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, HIGH);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, LOW);
}
void SEIS()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, HIGH);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, LOW);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, LOW);
}
void SETE()
{   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, HIGH);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, HIGH);
   digitalWrite(SEGMENTO_G, HIGH);

}
void OITO()
{
   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, LOW);
   digitalWrite(SEGMENTO_E, LOW);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, LOW);

}
void NOVE()
{   digitalWrite(SEGMENTO_A, LOW);
   digitalWrite(SEGMENTO_B, LOW);
   digitalWrite(SEGMENTO_C, LOW);
   digitalWrite(SEGMENTO_D, HIGH);
   digitalWrite(SEGMENTO_E, HIGH);
   digitalWrite(SEGMENTO_F, LOW);
   digitalWrite(SEGMENTO_G, LOW);

}

E para minha tristeza e insatisfação, um dos segmentos do primeiro digito está queimado portanto não liga e não forma o numero corretamente.
Mas nesse casso ele pode ser isolado via código e ainda assim tenho 3 dígitos!

Veja o vídeo:

O segmento queimado é o E do primeiro dígito, como pode ser visto no vídeo…

Então é isso aí! Até a pŕoxima.

por ferpinheiro Postado em Arduino

Robo controlado atráves de rede wireless

E aí pessoal!

Entrei em férias da faculdade, hoje (até que enfim…) conclui todas as 7 matérias com êxito e agora estou livre de aulas por pelo menos umas duas semanas! E para comemorar as férias resolvi fazer esse tutorial para mostrar o meu mais novo projeto (mini-projeto), um robô controlado por rede wireless. Esse robô utiliza o arduino e um shield xbee para fazer a comunicação com o meu computador.

O funcionamento básico é:

O shield Xbee prove uma comunicação utilizando protocolo ZigBee especificado pela IEEE 802.15.4, esse é um padrão que especifica a camada física e efetua o controle de acesso para redes sem fio pessoais de baixas taxas de transmissão, geralmente WPANs.

O objetivo do tutorial não é mostrar como configurar uma comunicação entre o arduino e o shield xbee pois está é uma tarefa simples e existem vários tutoriais na internet de como fazer isso. Para maiores informações a respeito do assunto acesse a página oficial do arduino que fala sobre isso. LINK AQUI.

Bem o código é muito simples e fácil, veja:

/*
# Autor: Fernando Krein Pinheiro
# Data: 07/07/2012
# Linguagem: C/C++

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

----------------------------------

O robo pode ser controlado pelas teclas
w,a,d,s.

       W

       ^
       |
A  <--- ---> D
       |
       v

       S
*/

#include <Servo.h>
#include <SoftwareSerial.h>

Servo motorDireita, motorEsquerda;
SoftwareSerial mySerial(2, 3);
char comando;

void setup()
{
  iniciar_Motor();
  Serial.begin(9600);
  mySerial.begin(9600);
}
void loop()
{
	if (mySerial.available())
        {
             comando = mySerial.read();
             Serial.print(comando);
             if(comando == 'a')
             {
                  rotacao_Esquerda();
             }
             else
             if(comando == 'd')
             {
                  rotacao_Direita();
             }
             else
             if(comando == 'w')
             {
                  rotacao_Frente();
             }
             else
             if(comando == 's')
	     {
                  rotacao_Re();
             }

        }
	else
            rotacao_Parado();
}

void rotacao_Parado()
{
   motorDireita.detach();
   motorEsquerda.detach();
}

void rotacao_Re()
{
   iniciar_Motor();
   motorDireita.write(0);
   motorEsquerda.write(180);
   delay(600);
   rotacao_Parado();
}

void rotacao_Frente()
{
   iniciar_Motor();
   motorDireita.write(180);
   motorEsquerda.write(0);
   delay(600);
   rotacao_Parado();
}

void rotacao_Direita()
{
   iniciar_Motor();
   motorDireita.write(180);
   motorEsquerda.write(180);
   delay(250);
   rotacao_Parado();
}
void rotacao_Esquerda()
{
   iniciar_Motor();
   motorDireita.write(0);
   motorEsquerda.write(0);
   delay(250);
   rotacao_Parado();
}

void iniciar_Motor()
{
   motorDireita.attach(10);
   motorEsquerda.attach(11);
}

Veja agora o resultado final.

Vídeo:

por ferpinheiro Postado em Arduino

Cliente – Servidor em C utilizando threads

Estou disponibilizando os fontes de um pequeno programa de cliente servidor implementado em C. Esse código utiliza threads na parte do servidor podendo controlar mais de um cliente.

Código Cliente. Para compilar utilize: gcc -lpthread -o cliente  cliente.c

/*********************************
Autor: Fernando Krein Pinheiro
Data: 04/07/2012
Linguagem: C
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
*/
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <ctype.h>
#include <string.h>

int configuracaoCliente()
{
    /*Descritor do cliente*/
    int clienteSockfd;
    /*Estrutura do Cliente*/
    struct sockaddr_in serv_addr;
    /*Tamanho da estrutura*/
    socklen_t addrlen = sizeof (serv_addr);

    /*Socket familia TCP declarado SOCK_STREAM e criado*/
    clienteSockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (clienteSockfd < 0)
	{
	    printf("Erro no Socket\n");
		exit(1);
	}
    /*Zera a estrutura*/
    bzero((char *) & serv_addr, sizeof (serv_addr));
    /*Seta a familia*/
    serv_addr.sin_family = AF_INET;
    /*Define o IP nesse caso o localhost*/
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    /*Define a porta de conexao*/
    serv_addr.sin_port = htons(6881);
   /*Faz a conexao com o servidor*/
   if(connect(clienteSockfd,(struct sockaddr *)&serv_addr, addrlen) < 0)
     {
        	printf("Erro no Socket\n");
		exit(1);
	}
        return clienteSockfd;
}

void Cliente(int clienteSockfd)
{
  /*Buffer de dados a ser mandado para o servidor*/
  char buffer_para_servidor[256];
  printf("Digite uma mensagem para o servidor: ");
   do {

        scanf("%s",buffer_para_servidor);
        fflush(stdin);
        /*Escreve para o servidor*/

        write(clienteSockfd, buffer_para_servidor, sizeof (buffer_para_servidor));

      /*Mensagem para sair*/
    } while (strcmp(buffer_para_servidor, "sair") != 0);
    /**Encerra o descritor*/
    close(clienteSockfd);
}

int main()
{
    system("clear");
    /*Estrutura cliente*/
    struct sockaddr_in serv_addr;
    /*Tamanho da estrutura*/
    socklen_t addrlen = sizeof (serv_addr);
    /*Define o descritor cliente*/
    int descritorCliente;
    descritorCliente = configuracaoCliente();
    /*chama funcao do cliente passando o descritor*/
    Cliente(descritorCliente);
    exit(0);
}

Código Servidor. Para compilador utilize: gcc -lpthread -o servidor  servidor.c

/*********************************
Autor: Fernando Krein Pinheiro
Data: 04/07/2012
Linguagem: C
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <pthread.h>

void* Servidor(void* arg)
{
    /*Buffer de entrada (armazena buffer do cliente)*/
    char buffer_do_cliente[256];
    /*Cast do ponteiro*/
    int sockEntrada = *(int *) arg;
    /*Loop "infinito"*/
    printf("Aguardando as mensagens... ");
    for (;;)
    {
        /*Le o que vem do cliente*/
        read(sockEntrada, buffer_do_cliente, sizeof (buffer_do_cliente));
        if (strcmp(buffer_do_cliente, "sair") != 0)
        {
            /*Se buffer == sair cai fora*/
            printf("%s\n",buffer_do_cliente);
        }
        else
             {
                 /*Encerra o descritor*/
                 close(sockEntrada);
                 /*Encerra a thread*/
                 pthread_exit((void*) 0);
             }
    }
}

int configuracaoServidor()
{
    /*Cria o descritor*/
    int sockfd;
    /*Declaracao da estrutura*/
    struct sockaddr_in serverAddr;
    /*Cria o socket*/
    if ((sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
	{
	  printf("Erro no Socket\n");
	  exit(1);
	}
    /*Zera a estrutura*/
    memset(&serverAddr, 0, sizeof (serverAddr));
    /*Seta a familia*/
    serverAddr.sin_family = AF_INET;
    /*Seta os IPS (A constante INADDR_ANY e todos os ips ou qualquer ip) htonl -> conversao*/
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    /*Define a porta*/
    serverAddr.sin_port = htons(6881);
    /*Faz a bindagem (cola, gruda, conecta seja o que for)*/
    if (bind(sockfd, (struct sockaddr *) & serverAddr, sizeof (serverAddr)) < 0)
    {
	  printf("Erro no Socket\n");
	  exit(1);
     }
    /*Fica na escuta de ate 5 clientes*/
    if (listen(sockfd, 5) < 0)
    {
	  printf("Erro no Socket\n");
	  exit(1);
    }
    return sockfd;
}

int main()
{
    system("clear");
    /*Declaracao da estrutura*/
    struct sockaddr_in serverAddr;
    /*Retorna da funcao e o descritor*/
    int sockfd = configuracaoServidor();

    /*Loop "infinito"*/
    while (1)
    {
    	int clienteSockfd;
    	struct sockaddr_in clienteAddr;
        /*tamanho da estrutura*/
    	unsigned int clntLen;
        clntLen = sizeof (clienteAddr);
        /*declara uma thread*/
	pthread_t thread;
	/*Fica no aguardo da conexao do cliente*/
        if ((clienteSockfd = accept(sockfd, (struct sockaddr *) & clienteAddr, &clntLen)) < 0)
        {
	  printf("Erro no Socket\n");
	  exit(1);
	}
        /*Inicializa a thread*/
        if (pthread_create(&thread, NULL, Servidor, &clienteSockfd) != 0)
       {
            printf("Erro na Thread\n");
            exit(1);
       }

        pthread_detach(thread);
    }
    exit(0);
}
por ferpinheiro Postado em C/C++

Automação residencial com Arduino – Parte I

E aí pessoal…

Vocês já pensaram em algum dia poder controlar a casa de vocês através da internet? Sim ou Não. Pois bem isso não é coisa do futuro, já existem diversos projetos de casas e ambientes que podem ser controlados dessa forma, porem, para se ter uma casa assim é preciso desembolsar alguma centenas de reais para ter todo o conforto e comodidade que essa tecnologia pode lhe proporcionar.

Na verdade, você teria que desembolsar se não existisse a plataforma arduino, pois com ela você pode ter um ambiente como esse citado acima, usando apenas a criatividade e algumas linhas de código.

Estou desenvolvendo um ambiente assim na minha casa, para aprendizagem e testes com a plataforma. O sistema é baseado utilizando linguagem C, PHP, e Python, através dele eu consigo ligar e desligar lampadas, monitorar a temperatura ambiente e outras funções ainda não implementadas.

Veja o vídeo que gravei e confira o resultado:
Para uma melhor visualização, use o modo tela cheia…

Simples não?!!

Com o projeto concluído será possível controlar a casa de qualquer aparelho que possua um browser e conexão com a internet. Continuem acompanhando o blog!

Até mais….

Utilizando Arduino para criação de Tecnologias Assistivas – Parte II

Continuando o projeto da nossa tecnologia assistiva para deficientes visuais, resolvi acoplar o prototipo em um boné para fazer alguns teste, também tive que fazer algumas modificações no código, principalmente na leitura do sensor ultrasonico, essa modificação teve que ser feita para melhorar a leitura e o tempo de resposta do sensor ultrasonico e consequentemente para o acionamento do motor de vibração.

Código:

/*********************************
Autor: Fernando Krein Pinheiro
Data: 23/05/2012
Linguagem: C (Wiring)
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
********************************/

#include <Ultrasonic.h>
#define echoPin 13
#define triggerPin 12

Ultrasonic ultrasonic(12,13);
int motorPino =  9;

void setup()
{

  Serial.begin(9600);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
  digitalWrite(motorPino, LOW);
}

void loop() {

  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  long tempo = pulseIn(echoPin, HIGH);

  //trunca o valor e faz com que seja um inteiro
  int distancia = calculoDistancia(tempo);

  if(distancia < 100)
  {
    digitalWrite(motorPino, HIGH);
  }
  else
   digitalWrite(motorPino, LOW);
   delay(100);
}

float calculoDistancia(long tempo){

  float segundos = (float) tempo / 1000000.0;
  float distancia = segundos * 340;
  distancia = distancia / 2;
  distancia = distancia * 100;
  return distancia;
}

Imagens do Prototipo:

Vídeo demonstrativo:

Repare que no eixo do motor existe uma pequena placa de cor vermelha e azul. Colei essa placa no eixo penas para uma melhor visualização, pois em alguns casos não era possível ver através do vídeo o acionamento do motor. A distancia mínima para o acionamento do motor no vídeo é de 30 centímetros.

As distancias utilizadas para testes foram:

2 metros.
1 metro.
50 centímetros.
30 centímetros.
20 centímetros.

Embora tenha sido curto o período de testes o prototipo mostrou-se bastante eficiente na leitura de todas as distancia e em momento algum houve erros de leitura pelo sensor ou de funcionamento do motor de vibração.

Conclusões sobre o trabalho:

A criação desse prototipo deve servir como um incentivo para a criação de tecnologias que auxiliem pessoas portadoras de necessidades especiais. O prototipo em questão não substitui de forma alguma as bengalas brancas usadas pelas pessoas com deficiência visual, pois os obstáculos como, degraus e muros com alturas inferiores a faixa da cintura de uma pessoa não são detectados por esse prototipo.

O uso de um motor de vibração menor é aconselhável, pois o que foi usado no projeto, além de ser grande e com uma estética ruim, ficará difícil de ser acoplado em uma placa. Aconselho então o uso de um motor de vibração menor que pode ser o mesmo encontrado em celulares.

O prototipo poderá ser construido utilizando dois sensores de ultrasom, um na altura da cabeça acoplado em um boné e outro em um cinto, pois assim poderá ser detectado obstáculos menores que a faixa da cintura de um individuo.

por ferpinheiro Postado em Arduino

Utilizando Arduino para criação de Tecnologias Assistivas – Parte I

“Tecnologia Assistiva é uma área do conhecimento, de característica interdisciplinar, que engloba produtos, recursos, metodologias, estratégias, práticas e serviços que objetivam promover a funcionalidade, relacionada à atividade e participação de pessoas com deficiência, incapacidades ou mobilidade reduzida, visando sua autonomia, independência, qualidade de vida e inclusão social” (ATA VII – Comitê de Ajudas Técnicas – CAT). Fonte. http://www.assistiva.com.br/

Agora que você já sabe o que é uma tecnologia assistiva, vamos ao projeto.

O objetivo desse tutorial é demonstrar como fazer o uso do Arduino para criação de um prototipo de tecnologia assistiva para auxilio a deficientes visuais.

O projeto consiste em monitorar a distancia de um obstáculo e avisar ao deficiente visual o quão próximo ele está do mesmo. Para isso utilizarei um motor de vibração e um sensor ultrasonico

O principio básico de funcionamento será: O deficiente visual utilizara o o prototipo junto a seu corpo, que poderá ser fixado tanto em forma de capacete, luva, ou cinto. Quando o usuário do protótipo estiver a uma distancia X de um obstáculo o motor de vibração será acionado indicando proximidade de algo.

Componentes utilizados para a criação do prototipo:

1 Arduino.
1 Motor de Vibração (Pode ser encontrado em controles de vídeo game ou celulares).
1 Diodo IN 4004.
1 Transistor TIP 122.
1 Resistor 2.2k ou equivalente.
1 Sensor Ultrasonico.

O motor de vibração retirei de um controle remoto de um vídeo game XBOX 360 que estava danificado, os demais componentes como diodo, resistor, e transistor retirei de uma lanterna e de uma fonte de computador. Algumas fotos da bagunça toda:

Esquema de montagem na protoboard:

Código fonte:

/*
# Autor: Fernando Krein Pinheiro
# Data: 20/05/2012
# Linguagem: C/C++

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
=================================
*/

#include <Ultrasonic.h>
#define echoPin 13
#define trigPin 12

Ultrasonic ultrasonic(12,13);
int ledPin =  9;

void setup()
{
  Serial.begin(9600);
  pinMode(echoPin, INPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(ledPin, OUTPUT);

}
void loop()
{
   digitalWrite(ledPin, LOW);
   int valor = func_distancia_ultrasonico();
    if(valor <=15)
    {
        digitalWrite(ledPin, HIGH);
        delay(100);
    }
  delay(500);
}
int func_distancia_ultrasonico()
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);

  digitalWrite(trigPin, LOW);
  int distancia = (ultrasonic.Ranging(CM));
  Serial.print("Distancia em CM: ");
  Serial.println(distancia);
  return distancia;
}

O vídeo abaixo demonstra o prototipo usando o sensor para medir a distancia. Caso a distancia seja menor ou igual a 15 CM (centímetros) o motor de vibração fica ativo indicando obstáculo a frente.

Repare como o motor vibra aos 1:10 minutos/segundos de vídeo quando removo a fita que segura o mesmo na bancada.

Esse é um exemplo prático de como irá funcionar o prototipo

Aguarde a parte II do tutorial que será para a montagem e testes…

por ferpinheiro Postado em Arduino

Controlando Motores DC com Arduino

Hoje vou demonstrar um protejo rápido e fácil de como controlar um motor DC utilizando arduino. Motores DC são motores que funcionam com corrente elétrica continua e são utilizados nas mais diversas áreas. Para controlar um motor desse tipo precisamos de uma corrente maior do que o Arduino pode fornecer, para conseguir amplificar a corrente vou utilizar um transistor TIP 122. Tambem usarei um diodo que servirá como proteção para a placa do Arduino, pois quando carregamos eletricamente o motor, uma parte dessa carga poderá voltar para o pino de controle e danifica-lo.

Vamos aos componentes:

1 Arduino.
1 Motor DC 5v.
1 Transistor TIP 122 (Pode ser TIP 120).
1 Resistor 2.2k (ou algum outro equivalente).
1 Diodo IN4004. (Ou IN4007).
Alguns Jumpers.

A alimentação do motor poderá ser feita através de fonte externa (pilhas ou bateria) que é o recomendável, ou pela própria placa Arduino no pino 5v. Alimenta-lo pela própria placa não é uma boa prática, mas quando não se tem outra alternativa, poderá ser feito dessa maneira.

Veja a ligação dos componentes:

Código para o funcionamento:

Repare que esse é o mesmo código que vem como exemplo na IDE do arduino com pequenas modificações. (Código Blink). Utilizei esse código apenas como demonstração pratica, você poderá altera-lo da forma que quiser.

int MotorPin =  9;

void setup()
{
  pinMode(MotorPin, OUTPUT);
}

void loop()
{
  digitalWrite(MotorPin, HIGH);
  delay(1000);
  digitalWrite(MotorPin, LOW);
  delay(1000);
}

Vídeo:

É isso então, até a próxima…

Bloqueando sites com IPtables

Esse tutorial foi feito por dois colegas de trabalho que encontravam alguns problemas em bloquear o site de relacionamento Facebook em sua rede wirelless. Após alguns dias de estudo e quebra cabeças eles conseguiram resolver o problema e me enviaram a dica que segue abaixo:

Tutorial criado por: Jocemar Luis Wammes com participação de Vitor Hugo de Souza.

Imagem simulando a rede:

Bloqueando Facebook por HTTPS (porta 443).

Como todo o administrador de rede sabe, o bloqueio de alguns sites é regra, até mesmo para o bom andamento do trabalho. Se for o caso de uma empresa ou a sobrecarga que as redes sociais como o facebook podem trazer quando nós nos referimos a uma instituição de ensino que é o nosso caso. Para começar vou descrever a situação que a gente enfrentava até poucos dias atrás.

Temos em nosso servidor de REDE o OS Suse , ótimo sistema operacional, e para controlar o bloqueio de sites optamos por instalar o Squid, até ai tudo bem não fizemos nada mais que redirecionar a porta 80 e a 8080 para a 3128(porta do Proxy), criamos também uma lista de sites de bloqueio que o squid analisa antes de rotear e duas ACLs dentro do Squid para liberar alguns IPs que poderiam acessar qualquer site. De um tempo para cá percebemos que o Facebook não obedecia a essa restrição simplesmente passava nosso Proxy (que é transparente), podemos observar então que a rede social passou a usar criptografia o HTTPS que sai pela porta 443, tentamos bloquear a porta 443, porém voltamos atrás devido ao pessoal que necessitava acessar sites de banco, começamos a buscar conteúdos e tutoriais até que encontramos algo que nos deu uma luz, então fizemos o seguinte.

1- Como nossa rede é separada fisicamente (diferentes placas de rede), a idéia é bloquear somente as redes wireless distribuídas para os alunos, optamos por bloquear pelo IPTABLES começamos com uma linha de comando mesmo, no SHELL:

Após isso desse mesmo computador que recebeu esse ip pingamos para esse servidor do Facebook e observamos que os pacotes não chegavam, tínhamos conseguido fazer a restrição, então apenas melhoramos a idéia.

2- Criamos um arquivo dentro de /etc/init.d chamado face, que nada mais é do que uma lista de servidores do facebook que estamos negando, a lista ficou gigantesca pois o facebook parece ter mais servidores do que habitantes na terra(hahaha). A lista ficou assim:

A regra toda:

*OBS: Por vezes percebemos que não bastava apenas dar um REJECT mas sim DROP para um mesmo IP,o memso aconteceu com o FORWARD
por vezes ele não bastava então aplicávamos INPUT E OUTPUT. Essa lista necessita ser atualizada frequentemente, pois com toda a certeza a facebook irá adquirir mais servidores.

3- Faça o arquivo se tornar um executável através do comando chmod +x nome_do_arquivo. Então no SHELL vá em /etc/init.d e digite o comando para reiniciar o arquivo ./nome_do_arquivo restart

4- Faça o arquivo iniciar junto com o SO quando for reiniciado através do comando. chkconfig nome_do_arquivo

5- Por final crie uma associação desse arquivo com o seu Firewall para que quando você reinicia-lo ele reiniciar junto.

Para restringir outros acessos como o twitter, Orkut é só implementar a lista com os determinados ips dos servidores dessas redes sociais ou qualquer outro site que você quiser bloquear. Se você quiser bloquear para toda a rede sem especificar faixa de rede é só fazer o seguinte:

Iptables -A OUTPUT -d 66.220.149.11 -j REJECT
Iptables -A INPUT -d 66.220.149.11 -j DROP

Bom é isso ai! Espero que esse tutorial ajude a todos que passam pela mesma situação que nós enfrentamos.

Para entrar em contato com o autor utilizem o email abaixo:

jocemarwammes[arroba]hotmail[ponto]com

por ferpinheiro Postado em Redes