RSS

Arquivo da categoria: arduino

Detector de batimentos cardíacos

Iai meus Leitores prediletos do meu blog falido 😛

Bom neste Post, vou falar sobre detector de mentira
algo simples em conjunto com um “heartbeat” , ideia do detector
de mentira não é só pegar batidas do coração mais pegar dados
de suor,movimentos da perna entre outras coisas significantes,
como nosso post vai ser informal não espere aqui um guia
definitivo de polígrafo.

moe

Nossa missão aqui é fazer um HeartBeat com um outro sistema
para pegar dados e fazer o Plot bem simples algo bem tabajara,
Plot é para a pessoa que vai julgar se é verdade ou mentira poder
ter algo visual, poderia ter usado um LED RGB para
ter seu valor atribuído de a cordo com valor do heartbeat, eu gravei
um vídeo para mostrar um ponto empírico. Agradeço ajuda do “Eremitah
por dar a dica do buzzer fez eu economizar uns 4 dollares com sensores
de tremor, buzzer você acha em qualquer lugar custa de 15centavos a
2 reais no máximo.

Foi usado apenas um buzzer , seria interessante usar mais de um, talvez
usar uma rede neural para pegar as batidas certas de forma descartar os erros e a ajudar no julgamento
de resultados de 4 sensores ou mais ,bem como sensor de umidade e movimento etc, talvez aumentar o delay de
5 segundos. fica a seu critério…

vamos a diversão,código do arduino

/*
author:Antonio Costa (Cooler_)
e-mail:c00f3r[at]gmail[dot]com

 Simple HeartBeat Detector with Arduino

 needs:
  1 resistor 1M ohms
  1 Buzzer
  1 Led +1 resistor 1k
  y finger on buzzer and run...

*/

#include <Time.h>  

// cada X segundos pega Y batidas
#define SEG 5

 int count=0;
 int ledPin = 6;
 int piezoPin = 5;
 int sensorValue = 0; 

void setup() {
 Serial.begin(9600);
 pinMode(ledPin, OUTPUT);
 pinMode(piezoPin, INPUT);
}

void loop()
{
 sensorValue = analogRead(piezoPin);
 if(sensorValue)
 {
  count+=sensorValue;
// light LED by knock
  digitalWrite(ledPin, HIGH);
  delay(25);
  digitalWrite(ledPin, LOW);
 }

 if( (!(second()%SEG)) && (count>20) )
 {
//  Serial.print("second:");
//  Serial.println(second());
//  Serial.print("HeartBeats:");
  Serial.println(count);
  count=0;
  delay(50);
 }
}

Agora código que vai ficar no nosso PC

/*
contato: c00f3r@gmail.com
autor: Antonio Costa aka Cooler_
coolerlab.wordpress.com

Simple Heartbeat detector with arduino

 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <time.h>

// sempre concatene com 'B' a  taxa de transmissão ,"9600" padrão do AVR
#define BAUDRATE B9600

// macros debug
#define BUGVIEW 1

#define DEBUG(x, s...) do { \
 if (!BUGVIEW) { break; } \
 time_t t = time(NULL); \
 char *d = ctime(&t); \
 fprintf(stderr, "%.*s %s[%d] %s(): ", \
 (int)strlen(d) - 1, d, __FILE__, \
 __LINE__, __FUNCTION__); \
 fprintf(stderr, x, ## s); \
} while (0);

// vai pegar os dados a cada 5 segundos
#define SECOND 5

int serialboot(const char* serialport, int baud);
int serialread( int fd, char* buf, char until, int max );
int WriteFile(char *file,char *str);

void banner()
{
 printf("\nFollow patern: ./heartbeat <SerialPort> <times 2 get>\n"
  "Just Another geek thing to get HeartBeat and plot!!!\n"
  "Coded By Cooler_\n"
  "coolerlab.wordpress.com\n"
  "\n");
}

int main(int argc, char *argv[])
{
 int baudrate = BAUDRATE,fd=0,counter=0,times=0;
 char *buf=malloc(sizeof(char)*16);
 char *serialport=malloc(sizeof(char)*512);

// apagamos o último log
 unlink("logbeat.txt");

  if(argc<2)
  {
   banner();
   exit(EXIT_SUCCESS);
  }

  printf("Serial:%s\n",argv[1]);

  strncpy(serialport,argv[1],sizeof(char)*511);
  fd=serialboot(serialport, baudrate);

   if(fd<=0)
   {
    DEBUG("veja se o dispositivo esta conectado!!");
    DEBUG("%d\n",fd);
    exit(EXIT_SUCCESS);
   }

//número de dados que seram pegos a cada 5 segundos
  if(strnlen(argv[2],3)<2)
  {
   times=atoi(argv[2]);
  } else {
   puts("error at argument time");
   exit(EXIT_SUCCESS);
  }

  while(1)
  {
   serialread(fd, buf, '\n',15);

   if(strncmp(buf," ",15)>0)
   {
    fprintf(stdout,"%s",buf);
    sleep(SECOND);
    WriteFile("logbeat.txt",buf);
    times--;
   }
// se terminar número de vezes então pula
   if(!times)
    break;
  }

// nosso amigão gnuplot nos ajudando 🙂
 FILE *pipe = popen("gnuplot -persist","w");
  fprintf(pipe, "set grid'\n");
  fprintf(pipe, "set style data lines\n");
  fprintf(pipe, "set terminal png\n");
  fprintf(pipe, "set output 'heartbeat.png'\n");
  fprintf(pipe, "plot \"logbeat.txt\"\n");
 pclose(pipe);

// fechando a banca xD
 puts("end HeartBeat, look image heartbeat.png");
 close(fd);
 free(buf);
 free(serialport);

 exit(EXIT_SUCCESS);
} 

int serialread(int fd, char* buf, char until,int max)
{
char b[1];
int i = 0;
do {
int n = read( fd, b, 1 );
if( n==-1 )
return -1;
if( !n )
{
usleep(16000);
continue;
}
buf[i] = b[0];
i++;
} while ( b[0]!=until && max != i );
buf[i] = 0;
return 0;
}

int serialboot(const char* serialport, int baud)
{
 struct termios toptions;
 int fd;

    fd = open(serialport, O_RDWR | O_NOCTTY | O_NDELAY);

    if(fd == -1)
    {
     DEBUG("serialboot: não foi possivel abrir a porta ");
     return -1;
    }

    if(tcgetattr(fd, &toptions) < 0)
    {
     DEBUG("serialboot: nao foi possivel pegar atributos do terminal");
     return -1;
    }
    speed_t brate = baud;
    cfsetispeed(&toptions, brate);
    cfsetospeed(&toptions, brate);
   // para default recv com termios.h
    // 8N1
    toptions.c_cflag &= ~PARENB;
    toptions.c_cflag &= ~CSTOPB;
    toptions.c_cflag &= ~CSIZE;
    toptions.c_cflag |= CS8;
    // no flow control
    toptions.c_cflag &= ~CRTSCTS;
    toptions.c_cflag |= CREAD | CLOCAL;  // turn on READ & ignore ctrl lines
    toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl
    toptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
    toptions.c_oflag &= ~OPOST; // make raw

    // olhe http://unixwiz.net/techtips/termios-vmin-vtime.html
    toptions.c_cc[VMIN]  = 0;
    toptions.c_cc[VTIME] = 20;

    if(tcsetattr(fd, TCSANOW, &toptions) < 0)
    {
     DEBUG("serialboot: nao foi possivel adicionar atributos no term erro 1");
     return -1;
    }

 return fd;
}

//escreve num txt
int WriteFile(char *file,char *str)
{
 FILE *arq;

 arq=fopen(file,"a");
  if(!arq)
  {
   DEBUG("error in WriteFile() %s",file);
   return 0;
  }
 fprintf(arq,"%s",str);
 fclose(arq);
 return 1;
}

$ gcc -o heartbeat heartbeat.c -Ofast -fstack-protector-all -Wl,-z,relro,-z,now -D_FORTIFY_SOURCE=fast
$ ./heartbeat /dev/ttyUSB1 10

deixe seu dedo indicador do braço direito no buzzer,
quando ver o LED piscar quer dizer que esta capitando…

*Dica caso queira testar em alguém
-faça um PCB , algo decente, o que mostrei foi só protótipo,use a imaginação
-use algum elástico de forma colar o buzzer no local onde quer capturar as batidas
-comece perguntando coisas que são obviamente verdade e analise o Plot
-preste atenção nos ticks nervosos
-olhe outros projetos hack a day ,por la tem vários polígrafos
-altere o delay e use mais buzzers se necessário

espero ter ajudado 😉

curtiu ? quer mais procura no google por “Knock sensor

Anúncios
 
1 comentário

Publicado por em dezembro 22, 2011 em arduino, hacking, Linguagem C

 

Tags:

the thief detector (detector de ladrão ) :-D

Post não vai ser sobre o carrinho de controle remoto com infravermelho
sim já terminei o protótipo dele já funciona, mas quero corroer a
placa fazer algo bem mais decente, invés de ficar usando breadboard.
como eu sou bem NOOB em tudo e em eletrônica este post vai demorar.

Olhe meu vídeo que você vai entender por que quero usar IR no carrinho

strikes back

Já algum tempo que comprei sensor de movimento para fazer um sistema
detector de “ladrão”, até pensei em usar um buzzer e tudo mais,
mas detector de ladrão com buzzer é muito manjado. Como eu gosto de trazer o que é
meio incomum para o blog então tive uma ideia…

Missão comunicação serial para quando for detectar o
movimento tirar uma foto da webcam e mandar e-mail com anexo a foto.
já tem soluções com o “motion” ou mesmo com opencv detectando movimentos
da webcam reconhecimento e tudo mais, mas a ideia do feito foi treinar
desenvolvimento com “arduino pro mini” em conjunto com “FTDI“…

material usado:
Arduino pro mini – $18.95 USD sparkfun (anda meio salgado o preço prefiro o diavolino )
Resistor 10k Ohm – $0.15 santa efigenia
Pir motion sensor – $9.95 USD sparkfun
Machine Pin headers – $2.00 santa efigenia (muito chato soldar isso no arduino)
FTDI Basic Breakout 5V – $12.00 USD sparkfun

vendo como fica
pronto1

seguindo a dica de
http://bildr.org/2011/06/pir_arduino/

código do arduino

int pirPin = 9; 

void setup(){
 Serial.begin(9600);
 pinMode(pirPin, INPUT);
}

void loop(){
  int pirVal = digitalRead(pirPin);


// achou movimento
  if(pirVal == LOW)
  { 
//pausa em milesegundos equivalente ao usleep do ansi C
     delay(500);
    Serial.println("1");
  }
  //sem movimento
  else
  {
    Serial.println("0");
  }

}

Lembra da nossa Missão ?
Se o arduino detectar valor com sensor de movimento
ira mandar um OUTPUT para a porta serial,nosso programa em C
irá ficar na esculta se ele julgar movimento do conjunto de
OUTPUT ele ira tirar uma SHOOT da WEBCAM e ira mandar e-mail
com anexo
a foto…

Vamos resolver o problema do E-mail,bom fazer um cliente de e-mail do zero
em C é trabalhoso e leva tempo, então vamos instalar cliente de e-mail
instalamos o “mutt

//use o gerenciador do seu OS,se for BSD use ports...
$ sudo apt-get install mutt
$ vi ~/.muttrc

set realname="seunome"
set from="exemplo@gmail.com;"
set my_user=exemplo@gmail.com
set my_pass='sua senha'
set smtp_url=smtps://$my_user:$my_pass@smtp.gmail.com
set ssl_force_tls = yes
:wq!

vamos testar

echo 'conteúdo do e-mail' | mutt -s 'assunto do e-mail' exemplo@gmail.com

e vá ver sua caixa de corrêio verificar…

como enviar nosso anexo ?

echo 'LogLog!!!' | mutt -s 'THief Get LOg' -a c/arduino/test.jpg -- exemplo@gmail.com

quer aprender mais sobre o mutt ? “man mutt

agora podemos partir para o código
não fique triste por eu ter usado o OpenCV para tirar foto da webcam

/*
contato: c00f3r@gmail.com
autor: Antonio Costa aka Cooler_
coolerlab.wordpress.com

Simples detector de ladrão usando Arduino+sensor de movimento

apt-get install libhighgui-dev  libcv
gcc -o thiefget thiefget.c  -lcv -lhighgui -lcxcore; ./thiefget

usei o OpenCV para tirar shoot da webcam pois não conheço outra API
que faça o mesmo...

só para enviar e-mail que usei programa de terceiro... parece gambi até xD

executando:
como argumento o seu dispositivo onde esta o arduino
./thiefget /dev/ttyUSB0


 */
#include <stdio.h>    
#include <stdlib.h> 
#include <string.h>   
#include <unistd.h>   
#include <termios.h>  
#include <fcntl.h> 
#include "opencv/cv.h"
#include "opencv/highgui.h"

// quantas vezes o sensor retornara 1 para mandar e-mail ?
#define MOVES 16

// numero que tolera erros
#define FAIL 16

// sempre concatene com 'B' a  taxa de transmissão ,"9600" padrão do AVR
#define BAUDRATE B9600

int serialboot(const char* serialport, int baud);
int serialread(int fd, char* buf, char until);
void webcam(const char* file);

void banner() 
{
 printf("\nFollow patern: ./PegaLadrao <SerialPort>\n"
  "Just Another geek Cool THing With ArduinO!!!\n"
  "Simple THief Get\n"
  "Coded By Cooler_\n"
  "coolerlab.wordpress.com\n"
  "\n");
}

int main(int argc, char *argv[]) 
{
 int baudrate = BAUDRATE,fd=0,counter=0,OFF=0; 
 char *buf=malloc(sizeof(char)*16);
 char *serialport=malloc(sizeof(char)*512);

  if(argc<2) 
  {
   banner();
   exit(EXIT_SUCCESS);
  }
    
  printf("Serial:%s\n",argv[1]);

//conection
  strncpy(serialport,argv[1],512);
  fd=serialboot(serialport, baudrate);

   if(fd<=0)
   {
    puts("veja se o dispositivo esta conectado!!");
    printf("%d\n",fd);
    exit(EXIT_SUCCESS);
   }
 
  while(1) 
  {
    
// tempo em milesegundos, altere como for necessário
   serialread(fd, buf, '\n');
   printf("====================\nread: %s\ncounter: %d\n===================\n",buf,counter);

// se ler "1" contador é atribuido
     if(strcmp(buf,"1")>0)
     {
      usleep(500000);
      puts("MOVEMENT ONLINE");
      puts(buf);
      counter++;
      OFF=0;
     } 
//numero de vezes que achou movimento
     if(counter==MOVES)
     {
      puts("cof cof thief in HOME");
      webcam("test.jpg");
      system("echo 'LogLog!!!' | mutt -s 'THief Get LOg' -a /home/nick/c/arduino/test.jpg -- exemplo@gmail.com");
      break;
      counter=0;
     } 
     if(!strlen(buf))
      OFF--;
     if(OFF==FAIL)
      break;
     
  }

 puts("Simple THief Get ,set to OFF");
 close(fd);
 free(buf);
 free(serialport);

 exit(EXIT_SUCCESS);    
} 

int serialread(int fd, char* buf, char until)
{
 char b[1];
 int i=0;
 do { 
  int n=read(fd, b, 1);  
  if(n==-1) 
    return -1;    
  if(!n) 
  {
   usleep(16000); 
   continue;
  }
  buf[i] = b[0]; 
  i++;
 } while(b[0]!=until);

 buf[i]=0;  

 return 0;
}

int serialboot(const char* serialport, int baud)
{
 struct termios toptions;
 int fd;

    fd = open(serialport, O_RDWR | O_NOCTTY | O_NDELAY);

    if(fd == -1)  
    {
     puts("serialboot: não foi possivel abrir a porta ");
     return -1;
    }
    
    if(tcgetattr(fd, &toptions) < 0) 
    {
     puts("serialboot: nao foi possivel pegar atributos do terminal");
     return -1;
    }
    speed_t brate = baud; 
    cfsetispeed(&toptions, brate);
    cfsetospeed(&toptions, brate);
   // para default recv com termios.h
    // 8N1
    toptions.c_cflag &= ~PARENB;
    toptions.c_cflag &= ~CSTOPB;
    toptions.c_cflag &= ~CSIZE;
    toptions.c_cflag |= CS8;
    // no flow control
    toptions.c_cflag &= ~CRTSCTS;
    toptions.c_cflag |= CREAD | CLOCAL;  // turn on READ & ignore ctrl lines
    toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl
    toptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
    toptions.c_oflag &= ~OPOST; // make raw

    // olhe http://unixwiz.net/techtips/termios-vmin-vtime.html
    toptions.c_cc[VMIN]  = 0;
    toptions.c_cc[VTIME] = 20;
    
    if(tcsetattr(fd, TCSANOW, &toptions) < 0) 
    {
     puts("serialboot: nao foi possivel adicionar atributos no term erro 1");
     return -1;
    }

 return fd;
}

/*tira foto usando opencv
  não queria usar opencv, mas unica API que ja tinha
 usado com a webcam...
*/
void webcam(const char* file)
{
 CvCapture *capture = cvCreateCameraCapture(0);
   if(capture==NULL)
    puts( "nao he possivel pegar foto!\n");

  IplImage* frame = cvQueryFrame( capture );
   if(!frame)
    puts( "erro na foto!\n");

  int imageParams[3] = {CV_IMWRITE_JPEG_QUALITY, 100, 0};
  cvSaveImage(file , frame,imageParams);
  cvReleaseCapture( &capture );
}

veja o e-mail que chegou quando cheguei proximo do sensor
e-mailcooler

muito divertido…

bom é isso ai,
escrevi o código meio que na correria mas acho
que deu para explanar a ideia…
fique avontade para melhorar o código 😉

 
8 Comentários

Publicado por em dezembro 4, 2011 em arduino, hacking, Linguagem C, segurança de sistemas

 

Micro estação meteorológica com arduino

Bom ideia partiu de um colega que trabalhou com meteorologia , ele precisava de um sistema
que armazena-se temperatura do tempo durante cada dia e depois de 30 dias ou mais ele
precisava saber o temperatura de cada dia, ele me mostrou o sistema que tinha feito com arduino,
bom pensei por que não fazer igual ? bom de primeira ele me aconselhou usar sensor digital
invés de analógico , usar baterias de lítio etc…

bom não terminei a micro estação meteorológica mas já andei fazendo alguns protótipos
vou ilustrar o que foi feito,olhamos o material

1X – protoboard
1X – 4.7K ohm Resistor
2X – DS18B20 (nosso sensor de temperatura)

vendo como fica na protoboard
sensortemp

Até aqui você deve de gastar uns 20 reais , mais para ficar mais legal vou usar
um display de LCD,não ter que passar os dados via porta serial…

veja meu video

o código

// coded by Cooler_

// vide http://www.arduino.cc/en/Tutorial/LiquidCrystal
#include <LiquidCrystal.h>
/* biblioteca de dallas
   cp -rf OneWire /usr/share/arduino/libraries 
   http://www.arduino.cc/playground/Learning/OneWire   
*/
#include <OneWire.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

OneWire  ds(7);  // pin of sensor
void setup(void) {
  lcd.begin(16, 2);
  lcd.print("Coded by Cooler_");
  delay(3050);
  lcd.begin(16, 2);
  lcd.print("irc.freenode.net ");
  lcd.setCursor(0, 1);
  lcd.print("#c-br #reset");
  delay(3050);
  lcd.begin(16, 2);
  lcd.print("Cogumelo Binario");
}

void loop(void) {
  byte i=0,x=0;
  byte type_s;
  byte valores[12],addr[8];
  float celsius;
  
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);         // inicia a conversão
  delay(1000);     // talvez 750ms  ou ñ

  x = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  while(i < 9) {           // precisamos de 9 bytes
    valores[i] = ds.read();
    i++;
  }

  // coverte var valores para temperatura atual
//escovação de bit padrão para o funcionamento
  unsigned int raw= ( valores[1] << 8 ) | valores [0];
  if(type_s) {
    raw = raw << 3; // 9 bit para esquerda
    if (valores[7] == 0x10) {
      // contador com 12bit
      raw = (raw & 0xFFF0) + 12 - valores[6];
    }
  } else {
    byte cfg=(valores[4] & 0x60);
    if(cfg == 0x00) raw = raw << 3;  // 9 bit res, 93.85 ms
    else if(cfg == 0x20) raw = raw << 2; // 10 bit res, 187.15 ms
    else if(cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms
    // padrão é 12 bit , 750 ms tempo da resolução 
  }
  celsius = (float)raw / 16.0;
//bota o cursor na linha de baixo para mostrar a temperatura
  lcd.setCursor(0, 1);
  lcd.print("temperatura:"); delay(30);
  lcd.print(celsius); lcd.print("-");
  lcd.print("Cogumelo Binario"); lcd.print("-");
}

Código bem simples para algo simples,ideia agora é usar um cartão SD
para gravar os dados e claro quando for guardar na caixa hermética tirar
o display de LCD não tem lógica usar o mesmo já que não queremos mostrar a
temperatura.

vou deixar link que estou estudando para conseguir trabalhar com cartão SD
http://code.google.com/p/sdfatlib/

 
1 comentário

Publicado por em novembro 8, 2011 em arduino, Linguagem C