Robô explorador (PARTE I)

O objetivo desse e de outros dois tutoriais que ainda virão é fazer a construção de um robô explorador. Esse robô deverá explorar ambientes de forma remota controlado via rede wireless.

Para isso utilizarei alguns componentes básicos:

1 -  Uma placa Arduino.
2 – Um shield Xbee.
3 – Uma camera wireless.
4 – Um sensor Ultrasonico.
5 – Um sensor de temperatura LM35.
6 – Alguns Leds (De preferência brancos).
7 – Dois Motores DC de 9volts. (Podem ser retirados de impressoras).
8 – Um CI de ponte H (L293D).
9 – Chapa de MDF (Para construção da carcaça).
10 – Duas baterias de 9 volts

Um esquema básico do funcionamento:

Um usuário poderá controlar o robô através de uma interface de comunicação HTML/PHP a qual envia dados através de uma rede wireless para esse robô. Nele estará acoplada uma camera wireless que transmitira vídeo em tempo real para o controlador (usuário), dessa forma poderá ser visto o ambiente em que o robô circula. Existe ainda um sensor de temperatura que monitora a temperatura local e em um tempo programado envia esses dados para o controlador. O sensor de ultrasom indicará possíveis obstáculos os quais não poderão ser vistos pela camera.

Pois bem, qual será a utilidade desse robô?

1 – Em primeiro lugar o aprendizado e experiência obtida no desenvolvimento do mesmo.
2 – Esse projeto servirá como base para outros experimentos.
3 – O robô poderá ser usado em lugares  “inóspitos” para a exploração. (Objetivo principal)
4 – Servirá como inspiração para outros desenvolveres.

Chega de papo furado e vamos ao que interessa. Vamos ver sobre o CI de ponte H L293D. Baixe o DATASHEET AQUI.

O esquema de ligação é como segue abaixo:

Mais fácil que isso só eu montado para você, rsrsrsrsrsrs brincadeira!

Não vou falar como conectar os outros componentes no arduino pois já fiz outros tutoriais mostrando como fazê-los, portanto antes de me perguntar procura mais informações aqui no blog mesmo!

Estou com parte do projeto já montado na carcaça, veja como ficou:


E um breve código apenas para ver o funcionamento:

    void setup()
    {

      pinMode(11, OUTPUT);
      pinMode(10, OUTPUT);
      pinMode(6, OUTPUT);
      pinMode(5, OUTPUT);

    }

    void loop()
    {
          motorParado();
          delay(1000);

          motorRe();
          delay(1000);

          motorEsquerda();
          delay(1000);

          motorDireita();
          delay(1000);

          motorFrente();
          delya(2500);

    }

    void motorFrente()
    {
      digitalWrite(11, HIGH);
      digitalWrite(6, HIGH);
      digitalWrite(5, LOW);
      digitalWrite(10, LOW);
    }

    void motorDireita()
    {
      digitalWrite(11, HIGH);
      digitalWrite(10, LOW);
      digitalWrite(6, LOW);
      digitalWrite(5, HIGH);

    }

    void motorEsquerda()
   {
      digitalWrite(11, LOW);
      digitalWrite(10, HIGH);
      digitalWrite(6, HIGH);
      digitalWrite(5, LOW);

    }

    void motorRe()
    {
      digitalWrite(11, LOW);
      digitalWrite(6, LOW);
      digitalWrite(5, HIGH);
      digitalWrite(10, HIGH);
    }

    void motorParado()
    {
      digitalWrite(11, LOW);
      digitalWrite(10, LOW);
      digitalWrite(6, LOW);
      digitalWrite(5, LOW);
    }

Com esse código é possível ver o funcionamento básico como andar para frente, vira para direita e esquerda e anda para trás. O próximo tutorial será para o desenvolvimento da interface HTML/ PHP e o restante do código Arduino para o Robô, portanto não deixe de conferir.

Até breve….

por ferpinheiro Postado em Arduino

Controlando o computador atráves de gestos

Na verdade o titulo do tutorial é um pouco “forçado”, mas a intenção aqui é demonstrar como é possível controlar algumas teclas do teclado através de gestos. Com isso você poderá por exemplo: fazer uma apresentação de slides (passar os slides) com apenas alguns gestos, ou ainda visualizar suas fotos de forma dinâmica sem precisar usar o teclado para isso, somente gestos.

Bem, para  fazer esse mesmo tutorial você precisa de um Arduino e um sensor ultrasonico. Também deverá estar em um ambiente Linux (hahahahaa usuário Windows) e ter instalado o emulador de teclado XDOTOOL e para completar a festa precisa de algum conhecimento na linguagem Python.

Não farei nenhuma explicação adicional e nem falarei sobre os componentes envolvidos, quem quiser saber mais sobre isso me contate via email.

Código Arduino:

/*
# Autor: Fernando Krein Pinheiro
# Data: 03/10/2012
# Linguagem: 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 8
#define trigPin 5

Ultrasonic ultrasonic(5,8);

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

void loop()
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  int distancia = (ultrasonic.Ranging(CM));
  Serial.print(distancia);
  delay(300);
}

Código Python

# Autor: Fernando Krein Pinheiro
# Data: 03/10/2012
# Linguagem: Python
# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
#! /usr/bin/env python

import serial
import os
import time
arduino = serial.Serial('/dev/ttyUSB0',9600)
while True:
	valor = arduino.readline()
        acao = int (valor)
        print acao

	if acao <= 20:
		os.system('xdotool key Down')
	else:
		continue

E com essas poucas linhas de código você tem esse resultado:

por ferpinheiro Postado em Arduino

Teclado 3×4 e LCD 16×2 com Arduino

Olá pessoal. Depois de muito tempo sem criar um novo tutorial, aqui estou eu novamente trazendo algo que possa ser útil para vocês!  O objetivo de hoje é conectar um teclado 3×4 ao arduino e utilizar um display LCD 16×2 para mostrar as informações digitadas no teclado. Qual a utilidade disso?

- Você pode por exemplo criar um sistema de alarme utilizando senhas.
- Controlar outros dispositivos como lâmpadas e motores digitando informações nesse teclado.
- Não terá necessidade de usar a comunicação serial através da IDE Serial Monitor do Arduino.
- Adaptar a outros teclados com mais teclas criando assim outros dispositivos, como por exemplo uma calculadora.

Bem vamos ao que interessa:

Primeiro precisamos de um teclado 3×4:

Note que esse teclado já possui alguma configuração básica que você irá precisar. Tendo isso em mãos, precisamos agora de um display LCD 16×2:

Precisamos ainda de um Arduino, 4 resistores de 10k para o teclado, 1 resistor de 1k para o display, uma protoboard e alguns fios para conexão.

Com isso em mãos já é possivel montar a parte de hardware. Agora passamos para a programação: Primeiro voce precisará da biblioteca Keypad.h que pode ser baixada AQUI.

Após ter feito o download da biblioteca inclua ele na pasta libraries do Arduino e procure informações sobre como usa-la. Essas informações podem ser encontradas AQUI.

As informações contidas no site são bastante úteis para quem quer usar esta biblioteca, lá você encontrara trechos de códigos para a implementação.

ATENÇÃO: Ficarei devendo a montagem no Fritzing, assim que sobrar um tempos a mais disponibilizarei no blog.
Mas caso não queira esperar você pode encontrar informações referentes AQUI. ou AQUI.

Código:

/*
# Autor: Fernando Krein Pinheiro
# Data: 03/10/2012
# Linguagem: C
# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
*/

#include <Keypad.h>
#include <LiquidCrystal.h>

const byte Coluna = 3;
const byte Linha = 4;

int i=0;
char Teclas[Linha][Coluna] = {{'1','2','3'},{'4','5','6'},{'7','8','9'},{'*','0','#'}};
byte Pino_linha[Linha] = {6, 12, 13, 9};
byte Pino_coluna[Coluna] = {8, 7, 10};

LiquidCrystal lcd(1, 11, 5, 4, 3, 2);
Keypad keypad = Keypad(makeKeymap(Teclas), Pino_linha, Pino_coluna, Linha, Coluna );

void setup()
{
   lcd.begin(16, 2);
}

void loop()
{
  char teclaPressionada = keypad.getKey();
  if (teclaPressionada != NO_KEY)
  {
        lcd.setCursor(i, 0);
	lcd.print(teclaPressionada);
        i++;
  }
}

Grande código hein?!!! rsrsrsrsrsr.

Um vídeo de demonstração:

por ferpinheiro Postado em Arduino

Lixeira eletrônica com Arduino

Alguns dias atrás minha mãe voltou de um passeio falando sobre uma lixeira eletrônica que ela havia visto, pela conversa pude perceber que ela estava realmente  fascinada pela tal lixeira. Foi aí que surgiu a idéia de eu criar a minha própria versão dessa lixeira para tê-la em casa.

Do que precisei para fazer a criação:

Um servo motor.
Um Arduino.
Um sensor ultrassônico.
Alguns cabos.
Um pouco de paciência para ouvir minha mãe falando sobre a lixeira (rsrsr, brincadeira).

Algumas fotos:

O Código:

/*
# Autor: Fernando Krein Pinheiro
# Data: 18/07/2012
# Linguagem: C
# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
*/

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

Servo myservo ;
Ultrasonic ultrasonic(12,13);

void setup()
{
  Serial.begin(9600);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
  myservo.attach(10) ;
}

void loop()
{

  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  long duration = pulseIn(echoPin, HIGH);
  int cm = microsecondsToCentimeters(duration);
  Serial.println(cm);
  if(cm <= 50 && cm >=5)
  {
       abreTampa();
       fechaTampa();

  }
}

void abreTampa()
{
    myservo.write(180);
    delay(3000);
}

void fechaTampa()
{
  myservo.write(0);
  delay(1000);
}

float microsecondsToCentimeters(long microseconds)
{
  float seconds = (float) microseconds / 1000000.0;
  float distance = seconds * 340;
  distance = distance / 2;
  distance = distance * 100;
  return distance;
}

Vídeo:

Então é isso aí…

Arduino e Matriz de Leds 8×8

Olá pessoal! Tutorial rápido de como usar uma matriz de leds 8×8 com o arduino. O esquema para montagem pode ser encontrado no site do Arduino nesse LINK.

A figura abaixo foi retirada do site arduino.cc referenciado no link acima:

Agora uma imagem de parte do datasheet da matriz:

E para finalizar, uma imagem da configuração da pinagem:

Agora um vídeo do funcionamento. A string escrita é o nome do blog “Compartilhar é preciso”.

 

Não disponibilizarei o código por enquanto pois existem alguns bugs que precisam ser corrigidos, mas assim que estiver funcionando 100% coloco aqui no blog.

Até a pŕoxima….

por ferpinheiro Postado em Arduino

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….