Social Icons

Mostrando postagens com marcador Arduino. Mostrar todas as postagens
Mostrando postagens com marcador Arduino. Mostrar todas as postagens

Game Genius com Arduino!

Jogo GENIUS, que é piscar os LEDs em uma sequência, repetidas vezes, para que o jogador possa acompanhá-la apertando os botões referentes as luzes que piscam completando a sequência até um total de 31 combinações. Até o momento, nenhum bug encontrado e estou implementando a interação do jogador com o jogo, que é a leitura dos botões quando pressionados e
compará-los a sequência criada.

Abaixo algumas fotos e um pequeno vídeo:

Suíte de programação Arduino



E o pequeno vídeo que preparei com a demonstração dos LEDs:



O projeto foi concluído com sucesso! Abaixo seguem algumas fotos e o vídeo final. O código fonte será disponibilizado, assim como o arquivo do programa Fritzing com o esquema eletrônico do PCB.



Circuito final #1

Circuito final #2
E uma demonstração do jogo em funcionamento:

E aqui os links:

Luminária RGB + Android com Arduino!


Material Utilizado para o protótipo:
  • Arduino
  • Celular com Android e Internet.
  • Shield Ethernet
  • 3 LEDs nas cores Vermelha, Verde e Azul (RGB)
  • Bateria de 9v
  • Armação da Luminária
  • Folha de Papel / Acrílico

Códigos Usados...

Medidor VU com Arduino

O medidor de VU é basicamente um medidor para o controle do sinal do som. Tentei achar o significado de VU na internet e nada, achei somente que vem de VI (Volume Indicator) 

Para este VU com Arduino Vamos precisar de:

1x Arduino Com 10 Saídas Digitas e 1 Analógica Disponiveis;
10x Leds(cores a sua escolha);
10x Resistores de 560Ω;
1x Cabo com entrada de audio e saida desemcapada(Um vai pro GND o outro pro Pino 0 do Arduino como veremos asseguir);


Circuito:




Pinos Digitais dos LED's(3 ao 12);
Pino de entrada de Som (0 Analógico);

Código Para Seu arduino:
int led[10] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; // definindo pinagem dos LED's
int leftChannel = 0; //canal de entrada de som
int left, i;
void setup()
{
for (i = 0; i < 10; i++) //definindo as saídas digitais
pinMode(led[i], OUTPUT);
// Serial.begin(9600); //Iniciando comunicação Serial
}
void loop()
{
left = analogRead(leftChannel); // lendo o sinal do som
// Serial.println(left); // enviando para serial sinal do som
left = left / 50; // ajuste de sensibilidade
// Serial.println(left); // mostrar sinal modificado na serial
// left = 1500; //pulso para testar leds
// left = 0;
if (left == 0) //se volume = 0 todos LED's estão Off.
{
for(i = 0; i < 10; i++)
{
digitalWrite(led[i], LOW);
}
}
else
{
for (i = 0; i < left; i++) // ligando os led's com dependência do volume
{
digitalWrite(led[i], HIGH);
}
for(i = i; i < 10; i++) // desligando os leds após o volume abaixar
{
digitalWrite(led[i], LOW);
    }
  }
}

Helicópteros com Arduino

Vagando pela nuvem achei vários exemplos de tutoriais com arduinos voando por ai...E aqui vai uma bela dica: não pesquise arduino no google se você esta procurando por projetos pesquise algo junto tipo "LED Arduino" ou algo assim pois só arduino te leva a sites simples que só tem o conceito e os famosos "hello world" e se você não aguenta mais isso #ficadica....
Seguindo aí uma breve introdução dos projetos para se ter uma idéia.

Esse abaixo é um helicóptero que possui Sensores IR para não bater em obstáculos, também conta com um sensor ultrasonico. Tem 4 hélices.





Vocẽ pode ver exemplos na internet como este:





Que possui 6 hélices e é acompanhado de um sistema GPS, controle wireless de alta frequência,(quem viu video sabe o porquê da alta frequencia).


Bom Acho que este post foi mais para dar uma idéia pra quem esta sem nenhum projeto e pesquisando para fazer algo novo por ai, estes brinquedinho dão bastante trabalho pois vi sobre um motor pra fazer levantar 500 gramas e ele não era caro, mas ocupava em torno de 29/35 Ampers, dai a bateria dele que fica cara, era uma NiPOH 2200mAh que custava 50 Dólares, acho que vale, mas tem quem prefira andar com uma bateria de carro pendurada...

Não sou vendedor dos links abaixo e nem conheço só achei no ML e quero dar uma luz ai pro pessoal perdido, pois depois de ler o cara fica com vontade não sabe nome seila e qualquer coisa os nomes e relação estão todos ai...

 Se quiser montar um dos acima pode usar algumas destas peças:


Especificações:
Dimensões: 35mm x 28mm, 51mm(incluindo o eixo)
Peso: 63g.
Consumo: 20~28A
Diametro do eixo: 3.17mm
Comprimento do eixo: 16mm
ESC recomendado: 40Amp.



Especificações:
Peso: 22g
Células: 2-3S
Corrente Máxima: 25A
Burst: 30A
BEC: 3A
Tamanho: 24x52x6 mm

Usando um Acelerômetro ADXL3xx

Neste exemplo veremos como usar um Acelerômetro analógico da série ADXL3xx (exemplos: ADXL320, ADXL321, ADXL322, ADXL330) e comunica a aceleração para o computador. Os pinos usados foram desenhados para serem facilmente compatíveis com as placas Sparkfun. O dispositivo ADXL3xx  potencia a aceleração em cada eixo com uma tensão análoga entre 0 e 5 volts, que é lida por uma entrada analógica do Arduino.


Um ADXL322 em uma placa Sparkfun inserido nos pinos de entrada analógica de um Arduino.


Tabela de pinos para a configuração acima:

Pinos da Placa Auto-Teste Eixo-Z Eixo-Y Eixo-X Terra VDD
Pinos de entrada analógica do Arduino 0 1 2 3 4 5

Ou, se você está usando somente o acelerômetro:

Pino ADXL3xx Auto-Teste Saída-Z Saída-Y Saída-X Terra VDD
Pino Arduino Nenhum (não conectado) Entrada Analógica 1 Entrada Analógica 2 Entrada Analógica 3 GND 5V

Código

int groundpin = 18;             // analog input pin 4
int powerpin = 19;              // analog input pin 5
int xpin = 3;                   // x-axis of the accelerometer
int ypin = 2;                   // y-axis
int zpin = 1;                   // z-axis (only on 3-axis models)

void setup()
{
  Serial.begin(9600);

  // Provide ground and power by using the analog inputs as normal
  // digital pins.  This makes it possible to directly connect the
  // breakout board to the Arduino.  If you use the normal 5V and
  // GND pins on the Arduino, you can remove these lines.
  pinMode(groundPin, OUTPUT);
  pinMode(powerPin, OUTPUT);
  digitalWrite(groundPin, LOW); 
  digitalWrite(powerPin, HIGH);
}

void loop()
{
  Serial.print(analogRead(xpin));
  Serial.print(" ");
  Serial.print(analogRead(ypin));
  Serial.print(" ");
  Serial.print(analogRead(zpin));
  Serial.println();
  delay(1000);
}

Dados

Básicamente ele fica atualizando a tela com a leitura do acelerômetro...
Aqui apresentamos algumas leituras coletadas por um acelerômetro posicionando o eixo Y de um dispositivo ADXL322 2g a vários ângulos do chão. Os valores devem ser os mesmos para outros eixos, mas podem variar de acordo com a sensibilidade do dispositivo. Com o eixo horizontal (por exemplo paralelo ao chão 0º) a leitura do acelerômetro deveria ser ao redor de 512, mas os valores para outros ângulos serão diferentes para cada dispositivo (exemplo de um ADXL302 5g).

Ângulo -90 -80 -70 -60 -50 -40 -30 -20 -10 0 10 20 30 40 50 60 70 80 90
Aceleração 662 660 654 642 628 610 589 563 537 510 485 455 433 408 390 374 363 357 355


O conteúdo desta página é uma tradução para o português a partir do site original do Arduino.
Esta obra está licenciada sob uma Licença Creative Commons.
Creative Commons License

Um Dimmer Futurístico



Um dimmer digital que pode ser facilmente acoplado no Arduino ou qualquer outra placa controladora. O resultado é que você consegue controlar a intensidade de brilho de uma lâmpada incandescente.  Dependendo dos circutos que você colocar neste esquema, você pode controlar um ventilador, chuveiro, ou fazer um ferro de solda com controle de potência!

Os desafios propostos neste desenvolvimento foram bem interessantes e pessoalmente foram verdadeiras aulas práticas de eletrônica e microcontroladores. 

A primeira tentativa que fizemos utilizamos um isolador ótico simples e tentamos usar a PWM para controlar a potência, mas o resultado com a lâmpada não deu certo: ela ficava piscando. Então Paulo pesquisou e me passou uma solução mais trabalhosa mas que funcionaria.

Neste novo esquema elétrico usamos dois isoladores óticos: 4N35 um MOC3021. O primeiro é utilizado para detectar a passagem da corrente alternada por zero e interromper o ATMega cada vez que isso acontecere, no caso do Brasil com 60hz, 120 vezes por segunda a corrente passa por 0. Neste momento é onde temporizamos  a abertura do TRIAC e simulamos o controle de potência. Veja o esquema elétrico:




Segue o código-fonte para Arduino. Você pode mudar a intensidade alterando o valor da variável dim entre 1 e 120, sendo que 1 é o mais forte e 120 praticamente desligada. Este programa permite alteração desta variável por I2C ou por Serial:


/*

#include 
int AC_pin = 3;
volatile long dim = 60;

void setup(){
  pinMode(AC_pin, OUTPUT);
  Serial.begin(9600);
  attachInterrupt(0, light, CHANGE);
  Wire.begin(66);
  Wire.onReceive(receiveEvent);
}

void receiveEvent(int howMany){
   char comando[16];
   int counter=0;
   while(1 < Wire.available())  {
   char c = Wire.receive();
   comando[counter++]=c;
   Serial.print(c);
      }  

int x = Wire.receive();
Serial.println(x);
Serial.println("Evento");
Serial.println(howMany);
//value, fromLow, fromHigh, toLow, toHigh)  
dim = map(comando[1], 48,57,10,120);
  } 


void light(){
  if(dim<125) {
    long dimtime = (60*dim);  // eval the proper pause to fire the triac
    delayMicroseconds(dimtime);  // delay the dim time
    digitalWrite(AC_pin, HIGH);  // fire the Triac
    delayMicroseconds(1);  // pause briefly to ensure the triac turned on
    digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)
  }  else {
      digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)  
  }
}

void loop(){
if (Serial.available() > 0) {
    byte inByte = Serial.read();
    dim = inByte;  }
}



E na etapa seguinte integramos este circuito com o ping da Parallax para ter o controle de intensidade "on the air". Bem, isso deixamos para um próximo post, por enquanto vai se divertindo com este circuito!

A lista de materiais para você comprar e montar:

- 4 resistores de 47K (R1 a R4)
- 1 resistor de 10k (R5) (se não tiver 1k e 10k não é eletrônica!)
- 2 resistores 330 (R6 e R7)
- TRIAC BTA16
- 1 isolador 4N35
- 1 isolador MOC3021

Preço da lista: menos que R$ 10.

Criador do Projeto:  Vinicius Senger
http://twitter.com/vsenger
http://twitter.com/eletronlivre
http://loja.eletronlivre.com.br
http://www.globalcode.com.br/instrutores/ViniciusSenger

Projeto EscaPe! v1.1



Ontem a noite sem nada pra fazer comecei a trabalhar com novos caracteres para a LCD Shield e aprendi a criar caracteres especiais com este site você tem uma idéia de como eles vão ficar.
Criei alguns avatares,bonequinhos,símbolos e gostei, pensei então em fazer o bonequinho andar na tela com os comandos:

 lcd.setCursor(x,y);
X=Valor de 0 a 15(no caso de LCD 16x2); - COLUNA
Y=Valor 0 ou 1 (Linha de cima ou de baixo) - LINHA

Recomendo quem quer entender o código por completo que leia o outro tutorial que fiz para o reconhecimento das teclas da shield lcd, pois irei usar o mesmo código para fazer com que vá para cima/baixo...







------------------------------------------
Nome do Jogo: EscaPe! 
Versões:
- 1.0: (Bugs simples logo serão corrigidos);
   1.1 (Implementado e corrigido 3 Bugs, ainda tem bastante bugs mas como estou sem muito                                  tempo talvez demore a concertar todos - Qualque ajuda é bem vinda).


No Pack de Download estão todas as versões para você poder avaliar a evolução.
Totalmente OPEN SOURCE: Download do Código (coloquei assim porque é muito grande o código para largar aqui, +-350 linhas)
User como quiser.
Você pode acompanhar notícias do jogo pela label EscaPe! aguardem muitas novidades até o fim do mês.

Reconhecendo Teclas com Shield LCD



Fiz um Exemplo rápido de como "Lêr" as teclas da shield LCD, é bem simples, todos os botões são ligados na mesma entrada Analógica, a 0, por isso para diferenciar as teclas são usados resistores, fazendo com que valores diferentes sejam interpretados pelo arduino.
Não sei se é o caso de todas mas na minha as teclas são organizadas dessa forma:


Fotos em Breve...

------------------------------------------------------------------
Tecla         - Valor:
Cima          - 146
Baixo         - 334
Direita        - 0
Esquerda    - 511
Selecionar   - 745
------------------------

Qualquer coisa se não for este valor, ou quiser saber como ligar faça assim:






1) Ache o Datasheet da Sua Shield e confira qual pino Analógico dos botões.
2) Coloque este código em seu arduino substituindo o indicado pelas suas informações.
3) Anote o valor de cada tecla e faça um "coeficiente de cagaço" ou seja a margem de erro, de uns 50 para mais e para menos, mas cuide para que este 50 para mais ou para menos não entre no valor de outra tecla.


#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
void setup(){
lcd.begin(16,2);
Serial.begin(9600);
}
void loop(){
  delay(1000);
  lcd.clear();
  int tecla_valor = analogRead(0);// 0  é o pino da sua entrada analógica
  lcd.print(tecla_valor);//tecla_valor armazena o valor lido e joga pra tela LCD.

}
5) Aqui está o código com os valores da minha Shield, ele lê a tecla e mostra qual é na tela.
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
void setup(){
lcd.begin(16,2);
Serial.begin(9600);
}
void loop(){
  delay(90);
  lcd.clear();
  int tecla_valor = analogRead(0);
  if (tecla_valor == 0)
{
  lcd.print("Direita 0");
  delay(100);
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
 
  lcd.print("Cima 146");
delay(100);
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
  lcd.print("Baixo 334");
  delay(100);
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
  lcd.print("Esquerda 511");
  delay(100);
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
  lcd.print("Selecionar 745");
  delay(100);
}
delay(50);
}

Como prometido criei um "menuzinho", percebam que está cheio de bugs ainda, quando você vai pra negativo e volta pra positivo ficam números errados na tela, e várias outras coisas, mas como estou ainda em fase de testes nesse projeto do Relógio vou desenvolver um menu para poder alterar a hora do relógio pelo sistema mesmo e não mais pelo source, então vou aos poucos mudando o código abaixo...
Se alguém conseguir avanços poste ai, OpenSource é isso!


#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
int up;
int down;
int nothing;
int right;
int left;
int enter;
int sel;
int x;
int y;
void setup() {   
lcd.begin(16, 2);
lcd.write(0);
sel = 0;
x = 0;
y = 0;
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 0;
}
void loop(){
  delay(100);
 
int tecla_valor = analogRead(0); 
if (tecla_valor == 1023){
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 1;
}
if (tecla_valor == 0)
{
  right = 1;
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
  up = 1;
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
  down = 1;
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
  left = 1;
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
  enter = 1;
}
delay(50);


lcd.setCursor(x,y);

if (down == 1){
  sel = sel -1;
}

if (up == 1){
  sel = sel + 1;
}
if (enter == 1) {
  (x=x+1);
}
lcd.print(sel);

}


Mais um exemplo, mas esse com menus escritos, tem 3 menus mas pode expandir para mais menus e sub-menus....


#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
int up;
int down;
int nothing;
int right;
int left;
int enter;
int sel;
int x;
int y;
void setup() {  
lcd.begin(16, 2);
lcd.write(0);
sel = 1;
x = 0;
y = 0;
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 0;
}
void loop(){
 

int tecla_valor = analogRead(0);
if (tecla_valor == 1023){
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 1;
}
if (tecla_valor == 0)
{
  right = 1;
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
  up = 1;
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
  down = 1;
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
  left = 1;
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
  enter = 1;
}
delay(120);

if (right == 1){
sel++;
 }
if (left == 1){
sel--;
 }

if (sel<=1){
  sel =1;
  lcd.clear();
lcd.print("     MENU 1  >> ");
 }
if (sel==2){
  lcd.clear();
lcd.print(" <   MENU 2   > ");
 }
if (sel>=3){
  sel=3;
  lcd.clear();
lcd.print(" <<  MENU 3    ");
 }
}

Hacking with an USB Host

Jogando Super Nintendo no Android com controle original

Jogando SNES com controle original via bluetooth
 http://www.youtube.com/watch?v=_FZTz2KO9vU .

Mas tem um detalhe muito importante este projeto, é para NES e não o SNES (mais novo), ou seja, sabia que era possível fazer e tinha os materiais para isto, então só esperei sobrar um tempo para fazer (o único componente que não tinha era o controle, mas consegui um paralelo por R$ 8,00 no Mercado Livre).

vimeo.com/bsoares/snes-on-android-with-controller-and-bluesmirf
Como funciona:
O controle do SNES esta ligado a Arduino, é bem fácil obter as teclas pressionadas, mas existe uma biblioteca para tornar esta tarefa ainda mais simples (NESpad/SNESpad). Cada tecla pressionada liga um bit dentro do número que representa o estado das teclas do controle, e este estado (número) é enviado via Bluetooth (uso o BlueSMiRF) para o Android.
No Android, quem recebe este número é o Amarino, mas ele apenas recebe o número, ainda é necessário um App (que foi modificado a partir deste exemplo “SoftKeyboard“) para converter este número em teclas pressionadas (uso Bitwise) como um teclado do Android.

Por fim é só configurar o emulador para entender as teclas pressionadas como os comandos dentro do mesmo (pular, andar, girar, etc…)

Desta forma o controle pode ser usado como o teclado do seu Android, e ainda ser configurado como o controle de outros emuladores.
Sobre o módulo bluetooth BlueSMiRF:
Depois de configurado ele será o seu “cabo USB virtual” pois da mesma forma que usamos o comando Serial.print(“…”) para enviar dados via porta serial, o mesmo dado será enviado via bluetooth.

A App Amarino utiliza 57.600 de baudrate, e os módulos BlueSMiRF normalmente vem com 9.600.

Para configurar o blueSMiRF utilizei alguns tutoriais:
- http://todbot.com/blog/2006/02/23/howto-mac-os-x-bluetooth-serial-port/
- http://www.sparkfun.com/tutorials/67

Sobre o Soft Keyboard (App para Android):

Modifiquei o exemplo de Keyboard App disponível no Android Developers para obter os dados via Amarino e agir como teclado. Me baseei neste projeto criado para NES, porém criei outro código para a Arduino e alterei 95% do código para o Android.
O código fonte do projeto para Androi, Arduino e as versões das bibliotecas que foram utilizadas, podem ser baixadas do meu Github:
https://github.com/BSoares/SNES-on-Android-with-original-controller

Os Códigos Usados estão aqui:

https://github.com/BSoares/SNES-on-Android-with-original-controller





Créditos para :
http://blog.bsoares.com.br/category/arduino#bitwise-right-shift

Robo Extremamente Simples com Arduino! [2]



É um robô muito simples, básico, com o objectivo de seguir linhas e ir desviando-se dos obstáculos.
Depois de ter tudo montado e a funcionar, quero adicionar a opção de escolher:
  • Seguir linha branca no fundo preto ou seguir linha preta no fundo branco
  • Ligar e desligar a função de seguir linha
  • Ligar e desligar a função de desviar obstáculos

Dificuldades Encontradas

Até agora, a dificuldade que encontrei foi na tentativa de construír o sensor de proximidade pelo tutorial do tr3s. Provavelmente os componentes que utilizei não estavam bons. Solução: Usar o sensor PING ))).

Estado Actual

  • llllllllll 100% - Base (circular)
  • llllllllll 100% - Montagem dos Motores Mini e Rodas
  • llllllllll 100% - Montagem do Servo para o Sensor Ultrasons
  • llllllllll 100% - Montagem dos sensores de reflexão para seguir linha
  • llllllllll 100% - Programação do Arduino para seguir linha
  • llllllllll 0% - Montagem do sensor PING)))
  • llllllllll 0% - Programação do Arduino para evitar obstáculos

Fotos

Vídeo


Código (Arduino)

  1. int ledPin = 13; // LED
  2. int senEsq = 0;   // Sensor da Esquerda
  3. int senMei = 1;   // Sensor do Meio
  4. int senDir = 2;   // Sensor da Direita
  5. int valEsq = 0;
  6. int valMei = 0;
  7. int valDir = 0;
  8. boolean Esq = false;
  9. boolean Mei = false;
  10. boolean Dir = false;
  11. int motores[] = {2,3,4,5};
  12. int pwm[] = {9,6};
  13. void setup() {
  14.  pinMode(ledPin, OUTPUT);
  15.  pinMode(motores[0], OUTPUT);
  16.  pinMode(motores[1], OUTPUT);
  17.  pinMode(motores[2], OUTPUT);
  18.  pinMode(motores[3], OUTPUT);
  19.  pinMode(pwm[0], OUTPUT);
  20.  pinMode(pwm[1], OUTPUT);
  21.  Serial.begin(9600);
  22.  digitalWrite(motores[0], HIGH);
  23.  digitalWrite(motores[1], LOW);
  24.  digitalWrite(motores[2], HIGH);
  25.  digitalWrite(motores[3], LOW);
  26. }
  27. void loop(){
  28.  valEsq = analogRead(senEsq);
  29.  valMei = analogRead(senMei);
  30.  valDir = analogRead(senDir);
  31.  if(valEsq < 100){Esq = true;}else{Esq = false;}
  32.  if(valMei < 100){Mei = true;}else{Mei = false;}
  33.  if(valDir < 100){Dir = true;}else{Dir = false;}
  34.  if(Esq)
  35.  {
  36.  // Virar para a esquerda
  37.  Serial.println("100");
  38.  analogWrite(pwm[0], 0);
  39.  analogWrite(pwm[1], 64);
  40.  }else if(Mei)
  41.  {
  42.  // Frente
  43.  Serial.println("010");
  44.  analogWrite(pwm[0], 64);
  45.  analogWrite(pwm[1], 64);
  46.  }else if(Dir)
  47.  {
  48.  // Virar à direita
  49.  Serial.println("001");
  50.  analogWrite(pwm[0], 64);
  51.  analogWrite(pwm[1], 0);
  52.  }
  53.  delay(10);
  54. }

Jeremy Blum Projects - Arduino Parte [10]

Este é da semana 10, trataremos sobre Interfaces SPI, Debouncing, Interruptores
Para quem não viu os outros(Recomendo seguir a Ordem):
Semana [1]
Semana [2]
Semana [3]
Semana [4]
Semana [5]
Semana [6]

Semana [7]
Semana [8]
Semana [9]
---------------------------------------------
----------------------------------------------



GNU GPL LicenseDistribuido apartir de GNU General Public (Open-Source) License.
Por Favor Compartilhe como "quiser".

Jeremy Blum Projects - Arduino Parte [9]

Este é da semana 9, trataremos sobre Interfaces SPI, xBee, Wi-fi, Wireless, 
Para quem não viu os outros(Recomendo seguir a Ordem):
Semana [1]
Semana [2]
Semana [3]
Semana [4]
Semana [5]
Semana [6]

Semana [7]
Semana [8]
--------------------------
 - Códigos Usados
 - Peças Usadas
--------------------------



GNU GPL LicenseDistribuido apartir de GNU General Public (Open-Source) License.
Por Favor Compartilhe como "quiser".

Um monitor de batimentos cardíacos para o ARDUINO







monitorBatimentos_01



Parte 1: “Vendo” os pulsos

Introdução

A Eletrônica nos permite criar aparelhos que são de fato extensões de nossos sentidos, como aqueles que são capazes de captar certos sinais fisiológicos que normalmente somos incapazes de sentí-los. Uma vez captados por algum tipo de sensor esses sinais podem ser amplificados e digitalizados, depois podem ser alterados e até mesmo controlados com alguma forma de feedback. Um desses sinais fisiológicos é o número de batimentos do nosso coração. Emoções fortes como raiva e excitação causam um aumento da taxa de batimentos do coração humano. Outras emoções como tristeza e pesar fazem essa taxa diminuir. Meditação, contemplação e outros estados mentais tambem mexem com essa taxa. Com a ajuda do Arduino e um amplificador de alto ganho com sensor ótico podemos monitorar nossa taxa de batimentos cardíacos na tela do nosso PC. Fica fácil assim montar um instrumento que pode ser usado para experiências com controle de stress, respiração, relaxamento e biofeedback





Hardware





Nosso protótipo foi montado numa pequena placa perfurada de 3,5 x 5,5 cm para ser encaixada sobre o Arduino como um shield. Veja a figura 1. Os componentes são interligados com pequenos fios no lado da solda da placa.

Nesse projeto utilizamos o par de amplificadores operacionais dentro do LM-358N.  O circuito completo está na figura 3, e é um projeto por nós adaptado para o Arduino a partir de um circuito originalmente publicado pela revista inglesa Elektor em 2008, sob o título “Stress-O-Meter”. Esse tipo de monitor de batimentos cardíacos é uma variante de um aparelho médico-hospitalar chamado pletismógrafo, que serve para medir (e registrar) variações no volume de um orgão como resultado de flutuações rítmicas da circulação do sangue pelo corpo humano. Normalmente nesse tipo de aparelho essas flutuações são captadas por um sensor ótico posicionado em um lado do lóbulo de uma orelha, ou um lado da ponta de um dos dedos, e com a fonte de luz alinhada no lado oposto. Diferentemente, nosso aparelho mede as pulsações no fluxo de sangue na ponta do dedo de uma das mãos do experimentador com o sensor e a fonte de luz colocados num mesmo plano e montados numa caixa separada do amplificador. Veja a figura 2 abaixo. Em nosso protótipo usamos como sensor de pulsações um LDR comum com uma resistencia de 1 Mohm sem nenhuma luz incidente, e 400 ohms com incidencia de luz natural direta.





Como fonte de luz para o sensor usamos um LED vermelho comum de 3 mm. O experimentador deve posicionar o lado oposto à unha de seu dedo indicador sobre o LDR, e a dobra entre a ponta e o meio do dedo sobre o LED. A luz que é emitida pelo LED atravessa a pele da dobra e é refletida pelo osso sobre uma pequena concentração de artérias bem em cima do LDR. O volume de sangue nesse grupo de artérias pulsa em sintonia com as contrações do músculo cardíaco. Essa informação vai modular a resistência do LDR.





No circuito do monitor o resistor R1 limita a corrente direta atraves de LED1 em cerca de 20 mA. O LDR e o resistor R2 formam um circuito divisor de tensão cuja saída pulsante será função da resistência do LDR que é função da luz refletida pelo dedo do experimentador.  

Esses pulsos de muito baixa frequencia, entre 1 e 2 hertz, seguem para um filtro passa-altas formado por C1 e R3 e é amplificado pelo primeiro opAmp do LM-358N na configuração não-inversor com ganho de 120. C2 e R5 formam um filtro passa-baixas centrado em 1,5 Hz. Essa frequencia corresponde a 90 pulsos por minuto, que é a metade da frequencia maxima do coração humano. O potenciometro P1, que é a resistencia de carga do primeiro amplificador, controla a entrada do segundo opAmp tambem não-inversor com ganho de 560. Aqui o sinal modulado com os batimentos do coração do experimentador pode ser entregue para tratamento ao Arduino no pino digital 2. O LED2 será programado para piscar com os batimentos cardíacos.



Sugerimos ao leitor primeiro montar o conjunto fonte de luz/sensor. Para o nosso protótipo montamos esse conjunto em uma pequena caixa plástica de 3x4x1 cm, como na figura 2. Nessa caixa foi montada a pequena placa perfurada com o LED vermelho de 3 mm e seu resistor de 270 ohms e o LDR e seu resistor de 39 Kohms.



Lista de componentes
R1 e R10 Resistor 270 ohms x 1/8W
R2 Resistor 39K ohms x 1/8W
R3 e R6 Resistor 68K ohms x 1/8W
R4 Resistor 8K2 ohms x 1/8W
R5 Resistor 1M ohms x 1/8W
R7 Resistor 560K ohms x 1/8W
R8 Resistor 1K ohms x 1/8W
R9 Resistor 1K8 ohms x 1/8W
P1 Potenciometro 10K linear
LED1 e LED2 Led vermelho 3 mm
LDR LDR
S1 Chave miniatura 1/0
C1 e C3 Capacitor 1uF x 25V
C2 e C4 Capacitor 100nF
CI1 LM-358N dual opamp
Outros Placa CI perfuração padrão
Borne 3 pinos parafuso


A distancia entre os centros do LED e do LDR é cerca de 1,0 cm. Da caixa saem tres fios: o de +5 volts, o de saída do divisor de tensão e o comum a esses dois, o terra. O fio de saída do divisor de tensão vai para o capacitor C1 na entrada do primeiro amplificador pelo borne B1.

Software

Depois de conferir mais de uma vez toda a fiação, encaixe o shield no seu Arduino, conecte o sensor e depois o cabo USB no seu PC. Para ver os batimentos cardíacos de uma pessoa carregue no seu Arduino o sketch da listagem 1.

Listagem 1


int pinLed = 3;    

volatile int state = 0;    



void setup(){

pinMode(pinLed, OUTPUT);        

attachInterrupt(0, pulse, CHANGE); 

}

void loop(){

digitalWrite(pinLed, state);     

}

void pulse(){

state = !state;           

}
Esse sketch configura o pino digital 3 como saída para LED2 no circuito, e o pino digital 2 como entrada de interrupção para a função attachInterrupt( ) que chama a função pulse( ) toda vez que uma interrupção externa ocorrer nesse pino. A função attachInterrupt( ) requer tres parâmetros e sua sintaxe é a seguinte:



attachInterrupt(pino, função, modo);
O primeiro parametro é pino e deverá ser 0 para o pino digital 2, ou 1 para o pino digital 3 do Arduino; o segundo é função e se refere à função que será chamada quando a interrupção ocorrer; o último parâmetro modo define o momento em relação ao sinal no pino digital especificado em que a interrupção ocorrerá, que poderá ser de quatro modos: CHANGE, na mudança do nível no pino; LOW, quando o pino for baixo; RISING, quando o pino mudar de baixo para alto; ou FALLING, quando o pino mudar de alto para baixo.

Nesse sketch toda vez que o nível lógico no pino digital 2 mudar, a função  pulse( ) será chamada, e esta vai somente complementar (mudar o estado da) a variável state. A variável state vai mudar de acordo com os batimentos do coração do experimentador e fazer o LED2 acender ou apagar conforme seu estado na função digitalWrite( )

Para testar o circuito basta você repousar a ponta de seu dedo indicador sobre o sensor e girar o cursor do potenciometro P1 para o mínimo ganho até o LED no pino 3 apagar. Depois vá aumentando o ganho até que o LED comece a piscar com os batimentos do seu coração. Depois de algum treino pressionando mais ou menos o dedo sobre o sensor é possível achar o ponto ótimo para ver o LED piscar regularmente. O ajuste fino é feito com o potenciometro.

Podemos enviar nossos batimentos cardíacos pela porta serial para o PC e ver no terminal do Windows ou do Arduino sua forma digital como uma combinação de traços horizontais com caracteres ASCII 95 e 45. Para isso acrescente ao sketch acima uma linha para iniciar a porta serial em 9600 bps e os comandos if que testam a variável state; se esta for falsa o caracter 45 será enviado para o terminal serial com a função Serial.write( ); se state for verdadeira o caracter 95 será enviado. Veja a listagem 2 e a forma dos pulsos na figura 5 abaixo. As pausas de 10 ms entre as transmissões evitam a sobrecarga do buffer da porta serial.

Listagem 2


int pinLed = 3;      

volatile int state = 0;   



void setup(){

pinMode(pinLed, OUTPUT);      

attachInterrupt(0, pulse, CHANGE);

Serial.begin(9600);

}

void loop(){

digitalWrite(pinLed, state);      

if(!state) Serial.write(45);

delay(10);

if(state)Serial.write(95);

delay(10);

}

void pulse(){

state = !state;                   

}



pulsosCardiacosTerminal Arduino 


Figura 5: os pulsos do batimento cardíaco

Na segunda parte desse artigo vamos visualizar melhor esses pulsos cardíacos agora digitalizados numa interface gráfica na tela do seu PC usando alguns poucos comandos de uma linguagem open source e muito parecida com a do Arduino, a linguagem Processing.(Já Comentada em Posts Anteriores)...

Até Lá!

Monte seu próprio Arduino ( Muito Fácil)

 



monte seu Arduino

 


As opções de Arduino

O Arduino já montado e testado pode ser adquirido em sites de comercio eletronico tanto aqui no Brasil quanto lá fora. Existe muitas opções de modelos conforme o microcontrolador embarcado, desde o mais simples com o ATmega168 com comunicação RS-232 ou USB e até aqueles com o ATmega1280 com mais memória de programa e mais entradas e saídas digitais. Mas tambem o leitor poderá montar seu proprio Arduino a partir de componentes facilmente encontrados em lojas de componentes eletronicos. Nesse caso propomos um circuito básico com o microcontrolador ATmega8 ou com o ATmega168, alguns resistores e capacitores, um regulador de tensão comum e um conjunto de conectores do tipo mini-latch para placa de circuito impresso. A placa proposta é de face simples e poderá ser confeccionada por qualquer método caseiro, como o já consagrado método térmico a partir de uma impressão a laser. A fonte de alimentação é externa à placa e pode ser qualquer carregador de baterias de aparelhos portáteis, como o de telefones celulares, que forneça tensões entre 9 e 15 volts CC. Veja o circuito completo do nosso protótipo na figura 1 e como ficou a montagem final na figura 2 abaixo.

 

circuito do Arduino
figura 1: circuito proposto para montagem

Hardware

Tanto o ATmega8 quanto o ATmega168 pode ser utilizado na montagem do nosso Arduino. Observe que no circuito não aparece o conversor TTL-RS232. Preferimos separar esse circuito da placa principal por uma boa razão: dar a opção ao montador de escolher que tipo de comunicação serial o seu Arduino terá com um PC, se RS-232 ou USB. Para a comunicação RS-232 existe o conversor MAX-232 que é um circuito integrado muito fácil de encontrar em lojas de componentes eletronicos, e por ser do tipo DIL de 16 pinos é tambem muito fácil de montar em uma pequena placa de circuito impresso e ser conectado por um cabo diretamente entre uma porta RS-232 do PC e o conector “SERIAL” que aparece no diagrama.Num outro artigo mostraremos a montagem de um circuito conversor TTL-Serial para ser usado com o nosso Arduino.

Para a comunicação serial USB o conversor é o FT-232RL, um circuito integrado do tipo SMD de 28 pinos, um pouco mais difícil de encontrar no comercio, bem mais caro que o MAX-232 e de montagem mais complicada numa placa de circuito impresso caseira devido ao tamanho e espaçamento entre seus pinos. Mas tanto um tipo quanto o outro de conversor funciona normalmente com o Arduino. A grande vantagem da USB é que todo PC moderno tem várias dessas portas disponíveis, e só os de mesa, os desktop, ainda estão vindo com duas ou tres portas RS-232.

Descrição do Circuito

O microcontrolador é alimentado com +5 volts nos pinos 7 e 20 provenientes do regulador de tensão integrado LM7805, se o jumper JMP1 estiver na posição “EXT”. Os capacitores C1 a C4 formam os filtros CC de entrada e de saída do regulador. No conector J1 entramos com uma tensão de +9 volts a +15 volts de uma fonte externa ou de um carregador comum de baterias com o positivo no pino central.

O diodo D1 serve de proteção para o circuito no caso de o pino central ser negativo. O LED1, vermelho, acende se a tensão de alimentação do circuito estiver correta. Essa mesma tensão externa tambem é disponibilizada no primeiro pino do conector “POWER”. A tensão de +5 volts do regulador LM7805 alem de ser disponibilizada nos pinos dos conectores “POWER” e “SENSOR” segue tambem para o conector “SERIAL” para alimentar a placa externa com o conversor RS-232.

À direita do diagrama temos o microcontrolador e os conectores ICSP, os dois digitais e o analógico. São 14 pinos digitais (D0 a D13) e 6 analógicos (A0 a A5). O pino de entrada de referência (AREF) para o conversor A/D do Arduino fica no segundo conector digital. O LED de teste e o pino 3 do ICSP estão ligados no pino digital D13. Na área tracejada vemos um cristal de 16Mhz e dois capacitores de 22pF que formam o circuito de relógio para o microcontrolador. Esse conjunto cristal-capacitores pode ser substituido por um ressonador cerâmico de 16Mhz que já inclui os dois capacitores no mesmo encapsulamento.

O microcontrolador uma vez configurado pelo bootloader do Arduino é resetado pelo último pino do PORT C (pino 1do microcontrolador), onde tambem temos um botão de RESET. Esse mesmo sinal de RESET segue para o pino 5 do ICSP e, atraves de um capacitor de 100nF, para o circuito conversor serial externo, para onde vão tambem os pinos digitais D0 e D1 que normalmente são reservados para a comunicação serial do Arduino com um computador PC ou com outro Arduino. Nesse conector  “SERIAL” pode ser ligado um circuito conversor RS-232 ou um USB. Se for usado um conversor USB o jumper JMP1 deve ser mudado para a posição “USB” e com isso o Arduino passa a ser alimentado pela tensão +5 volts da porta USB  do computador PC. É interessante observar que se não dispusermos de um carregador de baterias para conectarmos em J1 nosso Arduino pode ser alimentado por uma fonte externa de +5 volts diretamente atraves do conector “POWER”. O microcontrolador aparece no meio da placa.

Todos os pinos digitais e analógicos obedecem as mesmas posições e distanciamentos do Arduino padrão. Na parte de cima ficam os conectores digitais e à direita destes o conector “SERIAL” que acrescentamos para ligarmos a placa do conversor serial que será montada à parte. Na parte de baixo da placa está o jumper para selecionarmos que interface serial estamos usando, se RS-232 ou USB, e o conector analógico e o de tensões disponíveis para outros circuitos. À esquerda deste acrescentamos tambem um conector de tres pinos, o “SENSOR”, que é uma extensão do pino analógico A0, a tensão de +5 volts e o terra num só conector. À direita da placa, temos o botão de RESET e acima dele o conector “ICSP”. Mais abaixo do RESET o conector de entrada de tensão para alimentar o Arduino. Os outros componentes são os capacitores e resistores, o regulador de tensão e os dois LEDs. O LED vermelho acende para indicar que o Arduino está corretamente alimentado e o LED verde é o que vai conectado ao pino digital D13 do Arduino e indica quando carregamos programas para o microcontrolador. Em nosso Arduino utilizamos um ressonador cerâmico de 16 Mhz  em vez do cristal e dois capacitores de 22pF que aparecem no diagrama da figura 1. Nossa placa tem somente quatro pequenos jumpers

 

figura 2




Lista de materiais para a montagem do Arduino proposto
Item Componente qtde Obs.
1 Soquete DIL 28 pinos 1 Ou 2x DIL de 14 pinos
2 ATmega8 1 ou ATmega168
3 Cristal 16 Mhz 1 Ou ressonador cerâmico 16 Mhz
4 Regulador LM-7805 1 Não precisa dissipador
5 Diodo 1N4148 1 qualquer um da série 1N414x
6 LED 5 mm vermelho 1  
7 LED 5 mm verde 1  
8 Capacitor 100uFx25V 1 Tipo axial
9 Capacitor 10uFx25V 1 Tipo axial
10 Capacitor 100nFx100V 3 Tipo poliester
11 Capacitor 22pFx100V 2 Dispensados se usar ressonador
12 Resistor 220 ohms x 1/8W 2 Tipo cerâmico
13 Resistor 10 Kohms x 1/8W 1  
14 Botão tipo campanhia   1 Micro-chave para circuito impresso
15 Jumper 3 pinos 1 Jumper com espaçamento 2,54 mm
16 Conector mini-latch 8 pinos fêmea 2 Para os pinos digitais
17 Conector  mini-latch 6 pinos fêmea 1 Para os pinos analógicos
18 Conector  mini-latch 6 pinos fêmea 1 Para os pinos de tensões externas
19 Barra de pinos 6 pinos 90 graus 1 Para a placa serial
20 Conector mini-latch 3 pinos fêmea 1 Para a entrada de sensor
21 Barra de pinos 2x3 fêmea 1 Para o ICSP
22 Conector alimentação femea 1 tipo jack para circuito impresso

 

A placa de Circuito Impresso

A placa de circuito impresso do nosso Arduino tem 7,5 cm por 5,5 cm e é de face simples. Veja na figura 3 o lado da solda e na figura 4 uma sugestão de serigrafia no lado dos componentes na placa.

 



figura 3
Placa PCI Arduino 02

figura 4


A placa de circuito impresso pode ser confeccionada por qualquer método caseiro, como o já consagrado método térmico com impressão ou fotocópia a laser numa folha de papel grassy. Nesse caso deve-se usar o desenho da figura 5, sem inversão do lado da solda. Note que em nossa placa utilizamos um ressonador cerâmico na posição indicada como “XTAL”, se for utilizado um cristal e os dois capacitores ceramicos de 22 pF o desenho da placa deverá ser modificado para acomodá-los. Os pinos 8 e 22 (GND) do microcontrolador já vêm conectados entre si dentro do encapsulamento e portanto no desenho da placa não aparecem conectados.

 

placa PCI Arduino 03
figura 5
Uma vez pronta a placa de circuito impresso, o nosso Arduino pode ser todo montado em umas poucas horas, dependendo da experiência em montagens eletronicas do leitor. As unicas recomendações são para conferir mais de uma vez a montagem dos componentes polarizados, como o diodo, os capacitores eletrolíticos e os LEDs, e para se certificar que o microcontrolador está corretamente alojado e orientado no seu soquete. Confira tambem se os quatro jumpers (são quatro pedaços de fios finos) foram corretamente soldados nos seus respectivos lugares. Por fim, coloque o strap de JMP1 na posição “EXT”.



Alimentando o Arduino

Com o hardware do Arduino montado já podemos alimentá-lo, embora ainda não possamos controlar nada  com ele pois não temos nenhum programa carregado.  Você pode alimentar o Arduino de duas maneiras diferentes: ou com uma fonte externa ou um carregador para aparelhos portáteis com tensões entre 9V e 15V, como o da figura 6 abaixo; ou diretamente com uma bateria comum de 9 volts com um cabo adaptado para o plug da bateria e para o plug do módulo, veja a figura 6. O positivo da fonte deverá ser o pino central do conector macho que vai ligado ao Arduino.







figura 6



Ao conectar qualquer dessas fontes de tensão ao Arduino somente o LED vermelho deverá acender de imediato indicando que o módulo está alimentado corretamente.  Num outro artigo vamos montar um programador para o bootloader e o cabo serial e fazer nossos primeiros experimentos com o nosso Arduino.



 É isso aí, agora se você ja fez seu arduino ou ja tem um siga a página principal de Arduino do Blog e vá seguindo os tutoriais! Bom Proveito!

Não Me Responsabilizo por Nada Aqui escrito, se pegar FOGO é por sua Conta!