RSS

Arquivo do autor:cooler51

Sobre cooler51

Just Another Crazy Hacker. We judge people and initiatives by their results, and we expect events to happen for good, understandable reason. But our clear visions of inevitability are often only illusions.” ― Leonard Mlodinow, The Drunkard's Walk: How Randomness Rules Our Lives

Classificação K-nn rápida como the flash

Artist: Christopher Moeller

O método dos k vizinhos mais próximos (k-NN, do inglês k nearest neighbors) é um dos métodos de classificação automática mais usados na industria. Entretanto é comum problemas de performance com K-NN em linguagens interpretadas isso porque é tudo feito de forma genérica sem otimizações na parte da algebra linear(calma já explico), embora clusterizar seja interessante nestes casos no final torna-se um grande desperdício de energia e tempo.(deixe apra casos extremos)

Muitos processadores modernos tem recursos que não são usados por programadores comuns, fazer uso de um registrador RAX, no caso estaria usando apenas 64bits sendo que alguns processadores tem registradores de 128bits, 256bits e até 512bits, tais como XMM, YMM e ZMM(pensando em AVX).

“Se você pagou por uma ferrari, um dia você deve pensar em passar dos 60km/h”

Destravando todo esse poder dos registradores e instruções, podemos chegar a ter até 200% a mais de performance na algebra linear ou mais dependendo do contexto. O problema é que para programar usando intrinsics ou inline assembly pode ser tanto difícil, já que não é algo comum de se ver em cursos acadêmicos(comum para programadores de games ou aqueles que trabalham com criptografia).

Até aqui alguns devem de se perguntar, “há mas o GCC otimiza basta usar aquele argumento -Os, O3…” mesmo otimizando não é melhor(mais rápido) do que algumas implementações do Agner Fog por exemplo. Para ter algo empírico basta fazer benchmark e comparar as duas formas…

Apresento aqui uma solução para o problema de classificação usando K-NN em alta performance, existe uma biblioteca para linguagem C++ chamada armadillo, internamente essa bibliotéca tem recursos para usar o BLAS, LAPACK, SIMD otimizando assim a parte de algebra linear.

Desenvolvi uma biblioteca usando armadillo para classificar classes usando método K-NN, acabei testando no linux em uma distribuição debian, caso queira testar siga os passos:

1- Instale a lib do armadillo seguinto o comando:

$ apt-get install libarmadillo-dev

2- Configure o armadillo conforme sua necessidade seguindo o site oficial. http://arma.sourceforge.net/docs.html#config_hpp

3- Obtenha repositório do projeto, compile e faça um teste seguindo os comandos:

cooler@Nepal:/codes$ git clone https://github.com/CoolerVoid/libfast_knn
cooler@Nepal:~/codes/libfast_knn$ make
g++ -Wall -O3 -larmadillo -fstack-protector-all -D_FORTIFY_SOURCE=2 -c src/*.cpp -c lib/*.h -c lib/*.cpp
g++ -o bin/knn_test *.o -Wl,-z,relro,-z,now 
rm *.o

cooler@Nepal:~/codes/libfast_knn$ bin/knn_test 
Test Manhattan:
1:    5.0000   3.0000   1.6000   0.2000
	Result: 1
2:    1.0000   2.0000   1.6000   2.2000
	Result: 1
3:    6.0000   4.0000   4.6000   3.2000
	Result: 3
4:    0.9000   1.0000   2.6000   2.2000
	Result: 1
5:    9.0000   7.0000   4.6000   4.2000
	Result: 3

Test Euclidean:
1:    5.0000   3.0000   1.6000   0.2000
	Result: 1
2:    1.0000   2.0000   1.6000   2.2000
	Result: 2
3:    6.0000   4.0000   4.6000   3.2000
	Result: 3
4:    0.9000   1.0000   2.6000   2.2000
	Result: 2
5:    9.0000   7.0000   4.6000   4.2000
	Result: 3

Para aprender como usar a biblioteca basta ler o código no arquivo “src/main.c“.

Até o momento não existe implementação em Java, Python ou R que tenha maior performance, o consagrado MLpack usado até mesmo pelo google faz uso do armadillo, veja seus resultados em benchmarks.

Por que você implementou já que o Mlpack também faz K-nn ?

Mlpack é muito bom entretanto se precisa fazer uso de apenas de uma função K-nn, pode ficar triste quando notar a instalação do mlpack pedindo mais de 300mb de dependências. A curva de aprendizado é lenta já que a documentação do Mlpack é gigantesca. No meu código foi implementado algo simples a bala de prata certa para um problema específico, encontrei nada falando de classificação usando K-nn no MLpack, nem mesmo na sua documentação(logo a lib apresentada neste post é muito útil).

Para quem gostou do assunto e quer saber outras formas de ganhar performance fica uma dica tente usar GPU: https://github.com/vincentfpgarcia/kNN-CUDA

Referências:

https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm

http://www.mlpack.org/benchmarks.html

http://arma.sourceforge.net/speed.htm

Livro – Machine Learning in Action – Peter Harrington April 2012 ISBN 9781617290183 (embora seja em python os exemplos, aprendi muito).

Anúncios
 
Deixe um comentário

Publicado por em julho 9, 2017 em Linguagem C, Machine Learning

 

Um pouco de Assembly com linguagem C

Anos que digo para mim que vou escrever algo de “Assembly” vai ano e passa, acabo deixando
de lado, já algum tempo ando estudando fazendo coisas simples bem devagar, isso tem me ajudado a depurar meus programas em linguagem C, claro que também me ajuda nos skills de hacking seja com engenharia reversa ou para entender problemas que tenham  overflow, programar para um microcontrolador etc…

Se assembly fosse banda seria uma banda de heavy metal... rsrs

Se assembly fosse banda seria uma banda de heavy metal… rsrs

Antes de começar queria agradecer de coração “sigsegv“,”m0nad“,”iak“,”kov”,”__i”,”MySoft”,”muzgo”
por terem me influenciado em Assembly e ter me ajudado por muitas vezes e até hoje…
irc.freenode.net nos canais #asm,#c-br,#lisp-br,#cogubin.

“antes que me esqueça feliz pascoa caros leitores desse blog…”
Read the rest of this entry »

 
1 comentário

Publicado por em abril 7, 2012 em Assembly, Linguagem C

 

Biblioteca para Thread Pool

Tempos que não público nada, já algum tempo escrevi uma biblioteca em C
para piscinas de conexões,obtive dicas de amigos como Muzgo,
conto com a contribuição do Marcelo M. Fleury aka MarceloMF. se mais
gente poder ajudar seria legal, mesmo por que sou noob e preciso ter
uma visão de terceiros para evoluir….

Por que eu tive ideia de fazer ?
muito chato ficar fazendo malabarismo com mutex, queria algo tão simples
quanto o OpenMPI, algo que só apontando a função,número de threads a
usar e o número de vezes que os dados iriam rolar e pronto.
realmente tem me poupado horas a fio nos meus códigos com
programação concorrente.

Outra sou a favor do “tabula rasa” só faço abstração
quando tenho atitude a respeito(talvez por ter dislexia etc…),
ato de compartilhar não é por orgulho,vaidade e sim
pela sede de melhorar ,poderia ter deixado numa gaveta,
mas não !, deixo para todos só assim para ter esperança
de chegar a uma boa refatoração.

veja URL do PROJETO Aqui

Sem mais palavras “show me the code

$ wget http://tombpool.googlecode.com/files/tombpool02.tar.gz
$ tar zxvf tombpool02.tar.gz
$ cd tombpool02
$ mkdir pack; cd pack;
$ cmake ../; make; cd .. ; cp tombpool.h pack; cp test.c pack; cd pack
# cp libtombpool.so /lib
$ gcc -o test test.c -lpthread -ltombpool
$ ./test

olhando o código do test

/*
example how too use TombPool
 mkdir pack
 cmake ../; make; cd .. ; cp tombpool.h pack; cp test.c pack; cd pack
 sudo cp libtombpool.so /lib
 gcc -o test test.c -lpthread -ltombpool
 ./test

What this it ?
Just another thread pool simple api to work with double linked queue

Author:Antonio Costa aka " Cooler_ "
contact: c00f3r[at]gmail[dot]com
contributor: MarceloMF - Marcelo M. Fleury
email: marcelo.fleury[at]4linux[dot]com[dot]

    Copyright (C) 2012 tombpool authors,
    
    This file is part of tombpool
    
    tombpool is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    tombpool is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "tombpool.h"

void tarefa(int a)
{
 fprintf(stdout,"%d\n", a);
}


int main()
{
 int count=0;
// the pool struct	
 piscina* threadpool;
// init pool, to fill the pool, alloc heap ,4 thread per time            
 threadpool=Dig_TombPool(4);       

 while(count<10)
 {
// add task in pool and queue...
  Add_Corpse(threadpool, (void*)tarefa, (void*)count);
  count++;
 }	

// exec all and clear process, clear the heap,close semafores...
 Cover_TombPool(threadpool,10);
	
 return 0;
}

Por que tudo inglês ?
inglês é a lingua mais falada isso é clichê,e cai para nós
pessoal de portugal e brasileiro em geral tão nem ai para o
que ocorre em volta, já a 4 anos escrevo códigos OpenSource,
só escrevendo inglês para receber e-mails
de pessoas dando commit, dando dicas… mesmo meu inglês sendo fail 😉

você deve ter pensado por que estas funções
tem nome macabro
tipo “Add_Corpse()” ,” Cover_TombPool()
na verdade é um jargão ao tema de terror a imagem
do projeto também…
entomb

quando eu estiver de boa, vou fazer uma documentação
com doxygen se bem que para algo simples que não tem tanta função…
mas para ajudar a ficar sério ^^

 
1 comentário

Publicado por em março 17, 2012 em Linguagem C

 

Trabalhando com BigInt

Aloha queridos leitores, firmes como geleia ?! , hoje vou
tentar explanar algo comum, pode ser útil para quem trabalha com
estatística,física,aritmética pesada em geral ou desafios
Eulerianos” aqueles problemas com sigma com valores
com fatoriais monstros,acumulativos e recursivos,onde seu
computador pediria água de tanto serviço.

Quando você tem um número muito grande que ultrapassa a cota de uma
variável “int“, variável muda a casaca para negativo,não tem para
onde mais correr, e agora ? uso “long” certo e se o long virar casaca
também , e se o “long long” não der e nem com “unsigned“, Ho Ho parece
um dragão daqueles de múltiplas cabeças bem como Tiamat do D&D,
tiamat😀
bom obviamente você chegou a epifania de usar “char *“,usar alocação
dinâmica e já veio uma utopia na cabeça,uma possível solução para
nosso paradoxo, então você já sabe o que é um “BigInt“.

#include <stdio.h>

int main()
{
//tente concatenar mais alguns algarismos em X e compile e analise os resultados
 unsigned long long X=1844674407370955161;
 fprintf(stdout,"%lld",X);
 return 0;
}

Não vale o fardo seguir com a insanidade de como fazer do zero,
ainda mais mundo moderno onde muitos problemas já foram solucionados,
olhando em volta tocando uns livros e batendo uma busca no
Google a 2 anos atrás, encontrei o GMPGNU Multiple Precision
Arithmetic Library
“, uma API bem madura que proporciona o trabalho
com uma gamma de funções aritméticas, seja com variáveis integer,float
ou número racional, também conheci a lib para BigInt do OpenSSL mas
achei tão lenta que resolvi não escrever sobre. Quanto a otimização ?
GMP tem várias otimizações em ASM de acordo com a arquitetura do seu
computador, código fonte do GMP assusta até o Chuck Norris

Instalando:
# apt-get install libgmp-dev gmp-doc

Lendo o manual:
$ info gmp

agora que temos material em mãos

bom para usar a lib gmp usamos “gmp.h” e na hora de compilar usamos
o argumento “-lgmp“,vou explanar em algo empírico.

// exemplo by Cooler_
#include <stdio.h>
#include <gmp.h>

int main()
{
// var do gmp para trabalhar com signed int
 mpz_t X;
 unsigned int Y=512;
// inciando
 mpz_init(X);
// mnemônico para atribuição x=y
 mpz_set_ui(X,Y);
// mnemônico para soma x+=y
 mpz_add_ui(X,X,Y);
// 1024^512 qual seria o resultado ?
 mpz_pow_ui (X,X,Y);

 gmp_fprintf(stdout,"%Zd  %s\n",X,"legal");
/*
gmp tem um próprio método de OUTPUT
explicando o format string

     F         mpf_t, float conversions
     Q         mpq_t, integer conversions
     M         mp_limb_t, integer conversions
     N         mp_limb_t array, integer conversions
     Z         mpz_t, integer conversion

para INPUT use o gmp_scanf() e gmp_sscanf()
*/


/*
expoente
mpz_pow (mpz_t ROP, mpz_t BASE, mpz_t EXP)

resto
mpz_mod (mpz_t R, mpz_t N, mpz_t D)

testa se é divisível
int mpz_divisible_p (mpz_t N, mpz_t D)

adição
void mpz_add (mpz_t ROP, mpz_t OP1, mpz_t OP2)

subtração
void mpz_sub (mpz_t ROP, mpz_t OP1, mpz_t OP2)

produto
void mpz_mul (mpz_t ROP, mpz_t OP1, mpz_t OP2)

divisão
void mpz_div (mpz_t ROP, mpz_t OP1, mpz_t OP2)

raiz quadrada
void mpz_sqrt (mpz_t ROP, mpz_t OP)

comparar dois números
int mpz_cmp (mpz_t OP1, mpz_t OP2)
...

OBS: usamos "_ui" com nome da função quando precisamos usar "unsigned int"

*/


// limpando a bagunça
 mpz_clear(X);

 return 0;
}

Agora você pode ficar orgulhoso de conseguir fazer contas que uma calculadora
de mão não conseguiria fazer, evidente que todo conhecimento abre portas…

vamos a um desafio do project euler,algo bem easy
http://projecteuler.net/problem=48

vendo enunciado:
sequência , 1^1 + 2^2 + 3^3 + … 10^10 = 10405071317.
quanto seria até 1000^1000 ops apenas os últimos 10 dígitos

parece ser simples vamos fazer até 10 e pegar os últimos 5 dígitos

#include <stdio.h>
#include <math.h>
//coded by Cooler_
int main()
{
 unsigned long long sum=0;
// agora troque o count por 1000, e o digitos para 10
 short count=10,digitos=5;

 while(count)
 {
  sum+=pow(count,count);
  count--;
 }

 fprintf(stdout,"%lld ,last %d digits is %d\n",sum,digitos,(int)fmod(sum,pow(10,digitos)) );
 return 0;
}

compile e rode o programa e depois modifique como no comentário,
pensou em usar GMP ? e se você fazer de 10000000 ao invés de 1000 ?
como você faria ?

Meus agradecimentos ao utroz,enygmata e o kov do canal ##c-br da freenode
😉

 
4 Comentários

Publicado por em janeiro 13, 2012 em Linguagem C, math

 

Tags:

Migrando do excel para algum DB

Vou ser bem retórico, missão aqui é abrir vários arquivos
.xls“(extensão de arquivos do excel) que contenham a mesma
tabela,passar para XML e depois dar parser para dar “INSERT
em algum DB.

Justificativa da missão ,ano passado por 3 vezes eu
peguei freelancer de portar tabelas de “excel” para
algum SGBD, muita gente reclamando para mim que
gostaria de saber como o fazer e tudo mais foi outro
motivo, muitos clientes por falta de tempo e de estudo
preferem usar “excel” do que DB,pessoal de contabilidade
principalmente ,só olham para possibilidade de usar
banco de dados quando se tem milhares de tabelas do excel
para se alterar etc
, Isso é o que mantêm os estagiários em
algumas empresas,mas se perde muito tempo e dinheiro com
isso…
Read the rest of this entry »

 
Deixe um comentário

Publicado por em janeiro 6, 2012 em Banco de dados, Linguagem C, Perl

 

Uma humilde visão de Kernel,syscalls e módulos.

Não sou conhecedor de tudo que o sistema Linux tem , mesmo por que
uso a pouco tempo , mas vou tentar explanar alguns conceitos básicos,
dos quais me deparei no decorrer dos anos.

Kernel do Linux é um programa bem complexo escrito na linguagem “ansi C“,
com algumas partes específicas de cada arquitetura de computador utilizando
assembly“, sua missão é fazer o elo entre software e hardware. Quem já compilou
o kernel já teve o privilégio de ver uma tela com “ncurses” com uma das opções
“loadable Module”, se você ativar, poderá ativar e desativar drivers e funções,
maioria dos sistemas linux já vem com esta opção ativada , Estes módulos são
partes do “kernel” que possibilitam serem incorporados e removidos,sem a
reinicialização do sistema.

caso queira ver o código do kernel do linux
baixe o AQUI

Syscalls é um ponto de entrada para o kernel Linux, são chamadas indiretas
a maioria das chamadas de sistema têm correspondentes funções da biblioteca
C , um wrapper que executar os passos necessários (por exemplo, prendendo ao modo
kernel). Assim fazendo uma chamada de sistema é o mesmo que chamar uma função
de biblioteca normal.

tabkernel

antes de partir para o rock n roll, vamos entender o básico de inline ASM
__asm__("" : saida : entrada : modificador);

exemplo adição simples com “ADD”

#include <stdio.h>
#include <unistd.h>
 
int main()
{
  int data1 = 8,data2 = 3;
 
  __asm__("addl  %%ebx,%%eax":"=a"(data1):"a"(data1), "b"(data2));
  fprintf(stdout, "data1 + data2 = %d\n", data1);
 
  return 0;
}

Vamos analisar como um código em linguagem C ,interrupção para um syscall
no caso o write() , veja a tabela aqui

 int write(int fd,const char * buf,unsigned int count)
    {
        long __res;
        asm("int $0x80"
            : "=a" (__res)
            : "0" (__NR_write), "b" ((long)fd),
              "c" ((long)buf), "d" ((long)count));
        if ((unsigned long)__res >= (unsigned long)-129) {
            errno = -__res;
            __res = -1;
        }
        return (int) __res;
    }

de onde veio o “__NR_write” ?

$cat unistd_32.h | grep write
#define __NR_write 4

algo equivalente a

  write:
         pushl %ebx              ; adiciona ebx na pilha
         movl 8(%esp), %ebx      ; adiciona primeiro argumento em ebx
         movl 12(%esp), %ecx     ; adiciona segundo argumento ecx
         movl 16(%esp), %edx     ; adiciona terceiro argumento edx
         movl $4, %eax           ; adiciona _ _NR_write em eax
         int  $0x80              ; interrupção para syscall
         cmpl $-125, %eax        ; checa o retorno 
         jbe .PULA               ; se nenhum erro JUMP para PULA
         negl %eax               ; complementa valor em eax
         movl %eax, errno        ; adiciona resultado em errno
         movl $-1, %eax          ; seta eax para -1
  .PULA: popl %ebx               ; tira ebx da pilha
         ret                     ; returna chamando programa

Em caso de erro, a maioria das chamadas do sistema retornam um número
negativo erro (ou seja, o valor negado de uma das constantes descritas
na errno (3)). O wrapper da biblioteca C esconde esse detalhe do chamador,
quando uma chamada de sistema retorna um valor negativo, o wrapper
copia o valor absoluto na variável errno, e retorna -1 como o valor de
retorno do wrapper.

O valor retornado por uma chamada de sistema bem sucedida, varia da chamada,
mais detalhes estão descritos no manual de páginas individuais. GNU C Library (glibc)
fornece a interface de syscall que se conecta ao kernel e fornece o mecanismo
para transição entre o aplicativo de espaço de usuário e o kernel.

mais informações
$ man syscall
$ man libc

Voltando para módulos de kernel

Qual é a vantagem de trabalhar com módulos do kernel ?

Bom você não precisa reiniciar seu sistema operacional toda vez que quiser
testar um driver, fora a transparência em que o linux faz isso, ajuda na
otimização do mesmo.
Vamos na prática

Arquivo que contém o módulo é um “arquivo objeto”, bem como um programa
gerado com GCC para depois compilar,utilizando oa argumento “-c”(compile only),
eles contêm símbolos para ajudar o kernel no percurso de carregamento de registro,
em suma passam pelo filesystem onde esta como “arquivo objeto” para memória RAM na
parte destinada de programas sendo carregados por um syscall, no endereço correto
reservada ao kernel.

vamos fazer nosso primeiro módulo

Makefile:

KDIR := /lib/modules/$(shell uname -r)/build

# Objeto
obj-m = macacos.o

# Regra default do Makefile
default:
        $(MAKE) -C $(KDIR) M=$(PWD) modules
        @rm -rf *.mod* Module.symvers *.o *~ *.markers *.order

# Limpando objetos e afins
clean:
        @rm -rf *~ *.o *.ko

arquivo macacos.c

#include <linux/module.h>

int init_module(void)
{
 printk("macacos me mordam \n");
 return 0;
}

void cleanup_module(void)
{
 printk("saindo\n");
}

MODULE_AUTHOR("Cooler_ ");
MODULE_DESCRIPTION("Just another test");
MODULE_LICENSE("BSD");

Passamos alguns comandos para compilar e instalar nosso módulo
e um comando para conferir se o módulo foi inserido…

$ make; insmod macacos.ko; dmesg | grep macacos
[17205.255807] macacos me mordam

Para remover o módulo
$ rmmod macacos

Olhe que interessante analisando o arquivo “.ko” com comando “strings”
$ strings macacos.ko
macacos me mordam
saindo
srcversion=F9191437D66715B7ADCB1E5
depends=
vermagic=3.0.0-14-generic SMP mod_unload modversions 686
module_layout
Pprintk
mcount
macacos

Bom o “insmod” usamos para instalar módulos e o “rmmod” para remover
como foi mostrado no exemplo, além deles temos o “lsmod” para listar módulos
exemplo

$ lsmod | grep snd
snd_hda_codec_hdmi     31426  1 
snd_hda_codec_realtek   254125  1 
snd_hda_intel          24262  6 
   |                      |    \_referências de outros módulos...
   |_ Nome Modulo         |_memória usada pelo módulo

modinfo” para se obter informações do módulo
$ modinfo snd_pcm
filename: /lib/modules/3.0.0-14-generic/kernel/sound/core/snd-pcm.ko
license: GPL
description: Midlevel PCM code for ALSA.
author: Jaroslav Kysela , Abramo Bagnara
srcversion: B1C966040673ADEA6AD0FAA
depends: snd,snd-page-alloc,snd-timer
vermagic: 3.0.0-14-generic SMP mod_unload modversions 686
parm: preallocate_dma:Preallocate DMA memory when the PCM devices are initialized. (int)
parm: maximum_substreams:Maximum substreams with preallocated DMA memory. (int)

Isso foi uma breve introdução…

 
1 comentário

Publicado por em dezembro 27, 2011 em Linguagem C, Linux

 

Tags:

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

 
1 comentário

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

 

Tags: