TecnoMelque

Detecção de gestos com APDS-9960

2017-10-19T07:01:00.001-07:00

Objetivo

Identificar gestos mostrando a direção por setas em um display

O que foi usado

>> APDS-9960

O APDS-9960 é um sensor de gestos, cor RGB, luminosidade e proximidade. Projetado nativamente para embarcar celulares.
Nesse experimento usando um módulo com o sensor testamos a detecção de gestos.

>> Tensão de alimentação: 3.3VCC;

>> Interface de comunicação: I2C;

>> Endereço I2C: 0x39;

>> Resolução até 16 bits;

>> Função de interrupção programável com limite superior e inferior;

>> Alta sensibilidade pode ser usado atrás de vidro escurecido;

>> Desempenho em baixa luminosidade na detecção de proximidade, 0,01 lux;

>> LED IR integrado e driver de LED síncrono;

>> Faixa de detecção: 10 a 20cm;

>> Dimensões aproximadas: 1,4cm x 1,4cm;

>> Pinagem:

> VIN (+3.3)

> GND (-)

> SCL (relógio I2C)

> SDA (dados I2C)

> INT (interrupção)

>> Módulo matriz de leds com MAX7219

>> Pinagem:

> VIN (+5)

> GND (-)

> DIN (dada)

> CS (load)

> CLK (clock)

>> Arduino UNO

Montagem

Programa

O código utiliza a biblioteca da sparkfun para o APDS-9960 e foi baseado em um de seus exemplos.

LINK PARA BIBLIOTECA

Como o ID do sensor que usamos ( 0xA8 ) é diferente do da sparkfun ( 0xAB). Para funcionamento correto foi necessário alterar esse dado no arquivo da biblioteca: SparkFun_APDS9960.h na linha 34

Vem assim:
#define APDS9960_ID_1 0xAB

Alterar para:
#define APDS9960_ID_1 0xA8

Esse arquivo fica dentro da pasta "scr" que estará dentre da pasta da biblioteca : \SparkFun_APDS9960\src

Pode ser aberto com editor de texto como o WorPad ou NotPad++. Este ultimo é próprio para isso. Para salvar é necessário abrir como administrador.

>> Códgo


// apds9960//////////////////////////////////
#include <Wire.h>
#include <SparkFun_APDS9960.h>

// Pins
#define APDS9960_INT    2 // Needs to be an interrupt pin

// Constants

// Global Variables
SparkFun_APDS9960 apds = SparkFun_APDS9960();
int isr_flag = 0;

/////////////////////////////////////////////

int load = 10; // pino do arduino ligado a pino LOAD (CS)
int clock = 11; // pino do arduino ligado a pino CLOCK(CLK)
int dataIn = 12;  // pino do arduino ligado a pino DATA (DIN)

int *aux;

// figuras
int up[8] =   {8,12,14,255,255,14,12,8};
int down[8] = {16,48,112,255,255,112,48,16};
int left[8] = {24,60,126,255,24,24,24,24};
int rigth[8] = {24,24,24,24,255,126,60,24};
int near[8] = {129,66,36,24,24,36,66,129};
int far[8] = {0,0,0,24,24,0,0,0};


int e = 0;

// define  registradores de comando do max7219
// os registradores de digitos vão de 0xx1 a 0xx7

byte max7219_reg_decodeMode  = 0x09;
byte max7219_reg_intensity   = 0x0a;
byte max7219_reg_scanLimit   = 0x0b;
byte max7219_reg_shutdown    = 0x0c;
byte max7219_reg_displayTest = 0x0f;




void setup () {

  pinMode(dataIn, OUTPUT);
  pinMode(clock,  OUTPUT);
  pinMode(load,   OUTPUT);
  pinMode(APDS9960_INT, INPUT);

  Serial.begin(9600);
  digitalWrite(13, HIGH);  

//initiation of the max 7219
  maxSingle(max7219_reg_scanLimit, 0x07);      
  maxSingle(max7219_reg_decodeMode, 0x00);  // using an led matrix (not digits)
  maxSingle(max7219_reg_shutdown, 0x01);    // not in shutdown mode
  maxSingle(max7219_reg_displayTest, 0x00); // no display test
   
  for (e=1; e<=8; e++) { // limpa registradores
    maxSingle(e,0);
  }
  
// the first 0x0f is the value you can set
// range: 0x00 to 0x0f
  maxSingle(max7219_reg_intensity, 0x0f & 0x0f);    
  
  // Initialize interrupt service routine
  attachInterrupt(0, interruptRoutine, FALLING);
  // Initialize APDS-9960 (configure I2C and initial values)
   apds.init();
  // Start running the APDS-9960 gesture sensor engine
  apds.enableGestureSensor(true);
   
} 

void loop () {

   // havendo interrupção o flag vai a 1. A função handleGesture() é chamada
    if( isr_flag == 1 ) {
    detachInterrupt(0);
    handleGesture();
    isr_flag = 0;
    attachInterrupt(0, interruptRoutine, FALLING);
  }
}

void interruptRoutine() {
  isr_flag = 1;
}

// le do sensor que foi o gesto e
// chama a função escolheseta()
// passando o numero correspondente

void handleGesture() {
    if ( apds.isGestureAvailable() ) {
    switch ( apds.readGesture() ) {
      case DIR_UP:
        escolhe_seta(1);
        break;
      case DIR_DOWN:
        escolhe_seta(2);
        break;
      case DIR_LEFT:
        escolhe_seta(3);
        break;
      case DIR_RIGHT:
        escolhe_seta(4);
        break;
      case DIR_NEAR:
        escolhe_seta(5);
        break;
      case DIR_FAR:
        escolhe_seta(6);
        break;
     // default:
      //  Serial.println("NONE");
    }
  }
}


void escolhe_seta(int num)
{
  // escolhe a figura
 switch(num){
 
 case 1:
 aux = up;
 break;
 
 case 2:
 aux = down;
 break;

 case 3:
 aux = left;
 break;

 case 4:
 aux = rigth;
 break;

 case 5:
 aux = near;
 break;

 case 6:
 aux = far;
 break;

 
}
  // mostra no display
    for(int i=1;i<=8;i++)
   {
    maxSingle(i,aux[i-1]);                  
   }
 
  
}

void maxSingle( byte reg, byte col) 
{    
  digitalWrite(load, LOW);       // begin
  
  shiftOut(dataIn, clock, MSBFIRST, reg); //endereço de registrador
  shiftOut(dataIn, clock, MSBFIRST, col); // byte a ser gravado
     
  digitalWrite(load, LOW);    
  digitalWrite(load,HIGH); 
}

Modulo relé 16CH via WIFI com esp8266-01

2017-04-24T14:21:00.001-07:00

Objetivo

Controlar, via rede wifi, um módulo relé 16ch

O que foi usado

>> Módulo wifi ESP8266 ESP-01 Com o firmware ESP Easy gravado

Para saber como gravar o firmware ESP Easy no ESP8266 acesse:

Gravação e teste do firmware ESP easy no esp8266-01

>> Modulo relé 16 canais

O Módulo relé 16 canais

>> Tensão de alimentação: 12V;

>> Possui regulador de tensão integrado 5V o que permite alimentar o arduino e demais dispositivos através dos pinos de saída 5V e GND;

>> Sinal de acionamento, lógico: Nível baixo GND. O ideal para uso com o PCA9685 seria o com acionamento em nível alto já que o módulo parece inicializar com todos os pinos em nível baixo.

>> Modulo I2C PCA9685

A postagem: Controlador PWM 16 CH PCA9685 com servos e Led

trás mais detalhes sobre esse módulo.

Este modulo tem saída em PWM mas usaremos o valor máximo para HIGH ou 1 e o mínimo para estado LOW ou 0.

Montagem

Configurando o ESP-01

Com o firmware ESP Easy já gravado no ESP8266 é necessário fazer apenas uma simples configuração - Definir quais os pinos que serão usados para comunicação I2C.

O ESP-01 disponibiliza apenas 2 pinos de IO. Temos que configura-los como Clock e Data da comunicação I2C.

GPIO 0 >> SCL
GPIO 2 >> SDA

Com o seu ESP8266 ligado e conectado a rede acesse sua página de configuração através do IP como mostrado na postagem:Gravação e teste do firmware ESP easy no esp8266-01

Na guia hardware altere SDA para GPIO-2 e SCL para GPIO-0. Em seguida clique em Submit

Testes

Após a montagem e a configuração.
Para acionar um dos 16 relés fazemos da seguinte forma - Considerando os dispositivos conectados à mesma rede - (para controle via internet será necessário IP fixo ou serviços de ddns dinâmico como os oferecidos pelo NoIP, além das configurações de direcionamento de porta em seu roteador):

Através de um computador ou celular conectado na mesma rede passos o comando da seguinte forma:

http:// ESP IP address/control?cmd=pcapwm,pin,Level

Substituindo:

ESP IP address Pelo IP do ESP8266 em sua rede;

pin Pelo Pino do PCA9685 0 a 15 (que no nosso caso corresponde a um dos reles)

Level Pelo valor de pwm.
O PCA9685 é um módulo com saída em PWM por isso valor pode ser de 0 a 4095 (4096 níveis possíveis) Isso e interessante para controle de led, servo motores, etc. Nesse projeto utilizamos apenas os extremos para acionar o relé: "0" para nível baixo e "4095" para nível alto.

Exemplo:

Considerando o IP: 192.168.0.5

Para acionar o relé número 15 do módulo enviamos: http://192.168.0.5/control?cmd=pcapwm,15,4095

Para desligar o relé número 15 do modulo enviamos: http://192.168.0.5/control?cmd=pcapwm,15,0

No vídeo utilizei um aplicativo criado no APPInventor que faz basicamente o descrito acima.

Gravação e teste do firmware ESP easy no esp8266-01

2016-12-10T14:35:00.002-08:00

O ESP8266 é um módulo wifi que tem revolucionado por seu baixo custo e versatilidade. Ele traz em uma placa muito pequena um CI contendo os elementos necessários a comunicação wifi e um microcontrolador de 32bist além de um CI de memória.

Existem alguns modelos deste módulo. Todos os modelos utilizam o mesmo circuito integrado principal. Sendo diferentes basicamente em número de pinos disponibilizados na placa e no tamanho de memória e alguns outros componentes em certos modelos.

O módulo mais básico é o ESP-01. Ele sai de fábrica com um firmware que possibilita controla-lo via comandos AT através de sua interface serial RS232, nível de tensão TTL 3,3V. Nessa configuração ele funciona como um modulo wifi para um dispositivo externo, como o Arduino, por exemplo.

A nodemcu disponibiliza outros firmwares que possibilitam a programação do microcontrolado interno permitindo que o módulo funcione de forma independente de microcontrolador externo. Essa programação pode ser feita pela linguagem LUA através de interface adequada ou pela interface de programação do Arduino, adicionando-se para isso os módulos convenientes.

Uma terceira possibilidade, a que usamos aqui, é instalar no ESP8266 a firmware EASY ESP da letscontrolit.com. Esse firmware permite controlara vários dispositivos com comandos via web por um navegador de internet ou aplicativo. Quando necessário as configurações adicionais ao modulo poder ser feitas também via browser acessando através do endereço IP a página de configuração do modulo. Isso facilita muito o uso do ESP8266.

Montando o circuito para gravação

O primeiro passo caso não tenha um adaptador pronto para ligar o ESP8266 ao computador é montar o circuito abaixo ou circuito semelhante:

Observe:

a. A alimentação e comunicação deve ser em 3,3V

b. O pino GPIO-0 deve ser ligado ao GND para que seja possível gravar o firmware

Gravando o firmware no ESP8266-ESP01

O tutorial oficial para instalação do firmware no ESP pode ser visto no seguinte link

1 - Fazer o download do arquivo zip contendo o firmware e ferramentas. Descompactar. Link

2 - Clique duas vezes em "flash.cmd". Uma janela de comandos deve começar com três perguntas.

3 - Digite o número da porta COM em que está conectado o ESP8266 via modulo FTDI. Por exemplo se estiver conectado na porta COM9 digite 9.

4 - Digite o tamanho da memória flash de seu ESP8266, 512, 1024 ou 4096 (depende do modelo)

5 - Selecione a versão de compilação. 120 ou mais recente.

6 - A gravação será iniciada e terminará, aproximadamente como na seguinte tela.

7 - Após concluir a instalação do firmware pressionar o reset do ESP ou desligue e religue

Configuração preliminar

Assim que é ligado após a instalação do firmware do EasyESP o ESP8266 criará uma rede wifi que pode ser acessada com um celular, por exemplo, para configuração inicial. Isso permite que ele seja acessado para configurar sua conexão com a rede wifi em que deverá se conectar.

1 - Acessar a rede criada pelo ESP

REDE: ESP_0

SENHA: configesp

2 - Após conectar nessa rede será possível ajustar as configurações para que o ESP8266 possa se conectar em sua rede wifi.

Para isso acesse com qualquer navegador de internet o IP: 192.168.4.1

Será aberta a seguinte página:

Nela selecione sua rede wifi, digite a senha e pressione connect

Será exibido uma contagem regressiva e logo em seguida, dando tudo certo, será mostrado o IP do ESP8266 em sua rede wifi.

Com esse IP é possível acessar a página de configuração do ESP e também enviar comandos.

Teste com LEDs

Após conectar o ESP8266 a rede via wifi podemos fazer o seguinte teste.

Ligar um LED no GPIO-0 e GPIO-2. Conforme figura abaixo.

Para esse teste não será necessária nenhuma configuração adicional no ESP.

Controlar o estado dos GPIO do ESP com o EASY ESP pe bastante simples.

Utilizei um computador conectado a mesma rede em que está conectado o ESP8266

Para alterar o estado via browser enviamos o seguinte:

http://ESP_IP_address/control?cmd=GPIO,pin,state

Onde:

ESP_IP_address : IP do ESP8266 em sua rede

pin : Pino correspondente ao GPIO

state: Estado desejado para o GPIO. 0 para nivel baixo e 1 para nivel alto.

Por exemplo:

No meu caso o IP do esp8266 é 192.168.0.102. Então:

Para acender o led no GPIO-2 envio: http://192.168.0.102/control?cmd=GPIO,2,1

Para apagar o led no GPIO-2 envio: http://192.168.0.102/control?cmd=GPIO,2,0

Para apagar o led no GPIO-0 envio: http://192.168.0.102/control?cmd=GPIO,0,1

Para apagar o led no GPIO-0 envio: http://192.168.0.102/control?cmd=GPIO,0,0

Controlando módulo relé 16 canais via I2C com Arduino

2016-11-09T15:24:00.000-08:00

Objetivo

Controlar um módulo relé 16 canais com arduino através de interface em display de cristal liquido 16x2 via modulo I2C PCA9685

Cada canal do relé pode ser usado para controlar carga em até 240V / 10A. Como lâmpadas, pequenos motores e outros eletro-eletrônicos.

O que foi utilizado

Módulo relé 16 canais
Arduino UNO R3
LCD shield
Modulo I2C PCA9685 (nativamente um modulo para controle de servomotores)
Fonte 12V
Jumpers

O Módulo relé 16 canais

>> Tensão de alimentação: 12V;

>> Possui regulador de tensão integrado 5V o que permite alimentar o arduino e demais dispositivos através dos pinos de saída 5V e GND;

>> Sinal de acionamento, lógico: Nível baixo GND. O ideal para uso com o PCA9685 seria o com acionamento em nível alto já que o módulo parece inicializar com todos os pinos em nível baixo.

O LCD shield

>> Display LCD16x2 (pinos D4 a D10 do arduino)

>> 5 botões, ligados a apenas um pino analógico do arduino, o pino A0, via divisor de tensão.

quando um botão é pressionado seu valor correspondente (entre 0 e 1023) pode ser lido com a função analogRead(A0); . Dessa forma é possível identificar qual botão foi pressionado.

O Modulo I2C PCA9685

A postagem: Controlador PWM 16 CH PCA9685 com servos e Led

trás mais detalhes sobre esse módulo.

Montagem

Como funciona

O canal desejado é selecionado via botões UP e DOWN.
O display mostrará o estado do canal selecionado: ON ou OFF
Para alterar o estado do canal pressionar o botão SELECT e em seguida LEFT ou RIGHT para alternar entre ON e OFF. Após selecionar o estado desejado pressionar novamente SELECT para validar a alteração.

Programa

O PCA9685 é um modulo PWM, saída analógica então para usá-lo com o modulo relé trabalhamos nos extremos da saída PWM: 0V para nível baixo (aciona relé) e 4095 para nível alto (desliga relé). Se estiver usando um módulo relé com acionamento por nível alto será necessário inverter no programa onde tem 4095 para 0 e vice versa no local indicado.

É necessário adicionar a biblioteca: Adafruit_PWMServoDriver

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7); //LiquidCrystal lcd(RS,E, D4, D5, D6, D7);

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

int canal_state[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


// BOTOES

int DLY_BT = 300;
boolean Right;
boolean Up;           
boolean Down;
boolean Left;
boolean Select;

int cnt_canal = 0;


void setup() {
  
  //delay(1000);
  
  lcd.begin(16, 2);
  pwm.begin();
  pwm.setPWMFreq(1600);  // This is the maximum PWM frequency

for(int a= 0; a<16; a++)
pwm.setPin(a,4095); // pino, valor, inverte 

delay(1000);

lcd.print("Modulo rele 16CH");

  lcd.setCursor(0, 1);
  lcd.print("                "); 
  lcd.setCursor(0, 1);
  lcd.print("Canal ");
  lcd.print(cnt_canal + 1);
  if(canal_state[cnt_canal] == 0)
  lcd.print(": OFF");
  else
  lcd.print(": ON");


}

void loop() {
  

  Zera_bts();
  Le_bts();  // ler botoes

  if( Up == true && cnt_canal > 0)
  {
  cnt_canal --;
  lcd.setCursor(0, 1);
  lcd.print("                "); 
  lcd.setCursor(0, 1);
  lcd.print("Canal ");
  lcd.print(cnt_canal + 1);
  if(canal_state[cnt_canal] == 0)
  lcd.print(": OFF");
  else
  lcd.print(": ON");
  }
  else if( Down == true && cnt_canal < 15)
  {
  cnt_canal ++;
  lcd.setCursor(0, 1);
  lcd.print("                "); 
  lcd.setCursor(0, 1);
  lcd.print("Canal ");
  lcd.print(cnt_canal + 1);
  if(canal_state[cnt_canal] == 0)
  lcd.print(": OFF");
  else
  lcd.print(": ON");
  }
  
//  if(Down == true && cnt_canal == 16}
   
  
  
 // Zera_bts();
//  Le_bts();  // ler botoes
 
  if(Select == true)
 {
           lcd.setCursor(0, 1); 
           lcd.print("                "); 
           lcd.setCursor(0, 1);
           lcd.print("SetCanal ");
           lcd.print(cnt_canal + 1);
           if(canal_state[cnt_canal] == 0)
           lcd.print(": OFF");
           else
           lcd.print(": ON");
           
               Zera_bts();
               Le_bts();  // ler botoes
                        
              while(Select != true){
                
               Zera_bts();
               Le_bts();  // ler botoes
                
              if(Right == true || Left == true)
             {
              canal_state[cnt_canal] = ! canal_state[cnt_canal];
              lcd.setCursor(0, 1);
              lcd.print("                "); 
              lcd.setCursor(0, 1); 
              lcd.print("SetCanal ");
              lcd.print(cnt_canal + 1);
              if(canal_state[cnt_canal] == 0)
              lcd.print(": OFF");
              else
              lcd.print(": ON");
              delay(300);           
      
              }
              } 
              
                 lcd.setCursor(0, 1); 
                 lcd.print("                "); 
                 lcd.setCursor(0, 1);
                 lcd.print("Canal ");
                 lcd.print(cnt_canal + 1);
                 if(canal_state[cnt_canal] == 0)
                 {
                 lcd.print(": OFF");
                 pwm.setPin(cnt_canal , 4095);  // trocar para 0 se o modulo
                 }                             // acionar em nivel alto
                 else
                 {
                 lcd.print(": ON");
                 pwm.setPin(cnt_canal , 0);  // trocar para 4095 se o modulo
                 }                          // acionar em nivel alto
    }

}

///FUNÇÃO LÊ BOTÕES/////////////////////////////
// {50, 200, 400, 600, 800 };
 void Le_bts()
 {
   while( Right == false &&
             Up == false &&        
           Down == false &&   
           Left == false &&    
         Select == false )
   {
    
   int input = analogRead(0);   //le o pino analogico onde esta os botoes
   
   if (input < 40)
   Right = true;
   else if(input > 50 && input < 150)
   Up = true;
   else if(input > 200 && input < 300)
   Down = true;
   else if(input > 380 && input < 450)
   Left = true;
   else if(input > 550 && input < 700)
   Select = true;
  

   }
    delay (DLY_BT);
 }


///FUNÇÃO ZERA BOTÕES/////////////////////////////
 
 void  Zera_bts()                                                                                                       
   {
    
 Right = false;
 Up = false;        
 Down = false;    
 Left = false;    
 Select = false;    
    
  }

Controlador PWM 16 CH PCA9685 com servos e Led

2016-11-08T07:04:00.000-08:00

Teste com servos

Teste com leds

Foram utilizados os exemplo que acompanham a biblioteca da adafruit para arduino nos testes descritos aqui. Em breve postarei dois outros exemplos de utilização deste módulo, um deles com o ESP8266.

Com esse módulo baseado no PCA9685 é possível adicionar 16 portas de PWM de 12 bits ao arduino, ao esp8266 ou a outro microcontrolador com I2C. Pode controlar, por exemplo, 16 servomotores, 16 leds inclusive a intensidade do brilho, entre outras aplicações.

Características do módulo

>> 16 canais;
>> Resolução do PWM: 12bits 4096 valores possíveis;
>> Frequências: 40 - 1000Hz;
>> Tensão de alimentação 2,3 V to 5,5 V;
>> Corrente máxima saída (pinos de PWM) 25mA;
>> Tensão lógica: 3 a 5V;
>> Tensão para servos (V+) máxima: 6V;

Datasheet do módulo adafruit

Datasheet do CI

Pinagem:

Endereço I2C

A comunicação I2C utiliza apenas dois fios, um para clock (SCL) e outro para dada (SDA). Nela é possível, teoricamente conectar até 128 elementos em um mesmo barramento. Cada elemento é definido por um endereço. Esse endereço é definido via hardware. O fabricante seguindo as normas do padrão I2C determina o endereço ou faixa de endereços quando o dispositivo é projetado.

Neste módulo:

>> 64 endereços I2C possíveis;

>> Dois endereços reservados: LED All Call address (1110 000) and Software Reset (0000 0110);

>> Permite ligar, teoricamente, até 62 módulos no mesmo barramento I2C. Endereço padrão 0x40 (em hexadecimal) , B1000000 (em binário)

O endereço I2C pode ser alterado através dos jumpers A0 a A5 na placa. Eles estão todos abertos por padrão.

Para mudar o endereço basta fechar com solda, alterando o bit para 1, o(s) jumper(s) correspondente ao endereço desejado. Observe que o primeiro dígito do endereço é fixo.

fixo	A5	A4	A3	A2	A1	A0	jumper fechado (1). aberto (0)
1	0	0	0	0	0	0	endereço padrão ( todos os jumpers abertos)

Fechando o jumper A0, por exemplo teremos o endereço !2C: B1000001 (em binário) ou 0x41 (em hexa)

Ligação com os servos

Ligação com os leds

O programa

Conforme mencionado no inicio foram utilizados os código que acompanham a biblioteca da adafruit. Ela pode ser baixada pelo link abaixo.

Biblioteca para arduino

Esta biblioteca tem 2 exemplos:

pwmteste >> usado no exemplo dos leds
servo >> usado no exemplo dos servos

Arduino termômetro sem contato MLX90614

2016-10-19T12:01:00.000-07:00

O que foi usado?

Sensor MLX90614;
Arduino UNO;
Display LCD 16x2 com módulo I2C;
Protoboard (para facilitar a conexão do display e sensor ao arduino);
Jumpers diversos;

Ligação:

O que faz?

Lê a temperatura ambiente e a temperatura do objeto, pessoa, etc que esteja na frete do sensor, a cerca de 2 ou 3cm de distância, e mostra no display.

Datasheet do sensor
Biblioteca do sensor
Biblioteca do display

Código (adaptado do código que acompanha a biblioteca do sensor)

// adaptado do exemplo da bibliteca:
// https://github.com/adafruit/Adafruit-MLX90614-Library

byte grau[8] = {   0b00110, // byte para criar o caracter grau
                   0b01001,
                   0b01001,
                   0b00110,
                   0b00000,
                   0b00000,
                   0b00000,
                   0b00000 };
// bibliotecas             
#include <Wire.h>
#include <Adafruit_MLX90614.h>
#include <LiquidCrystal_I2C.h>

// instanciando objetos lcd e mlx
LiquidCrystal_I2C lcd(0x27,16,2);
Adafruit_MLX90614 mlx = Adafruit_MLX90614();

void setup() {

  mlx.begin(); // inicialieza sens. de temp
  lcd.init(); // inicializa displau
  lcd.createChar(1, grau); // cria caracter ( º )
   
  lcd.backlight();
  lcd.print(" Teste MLX90614 ");
  delay(1000);
  lcd.clear();
}

void loop() {

  // escreve temp ambiente

  lcd.setCursor(0,0);  
  lcd.print("Amb.: "); 
  lcd.print(mlx.readAmbientTempC()); 
  lcd.print (" ");
  lcd.write(1); 
  lcd.print ("C");
  
  // escreve temp do objeto 
  
  lcd.setCursor(0,1);
  lcd.print("Obj.: ");
  lcd.print(mlx.readObjectTempC());
  lcd.print (" ");
  lcd.write(1);
  lcd.print ("C");
  
  delay(500);
}

Sensor de vibração, batidas ( knock sensor)

2016-10-10T18:42:00.000-07:00

Esse sensor é bastante simples. Consiste basicamente de dois contatos próximos, um fixo e outro ligado a uma mola. Havendo vibração suficiente para fazer a mola tocar o contato fixo, causada por uma batida no sensor ou na superfície em que ele esteja fixado, por exemplo, a saída, normalmente em nível alto (vcc), vai momentaneamente ao nível baixo (GND).

O sensor:

Abaixo o diagrama do sensor:

Em seguida a ligação com arduino usada no exemplo:

Código:

int pin = 8;
int led = 13;
int sensor;
boolean led_state = false;

void setup()
{

  pinMode(pin, INPUT);
  pinMode(led, OUTPUT);

}

void loop()
{
  sensor = digitalRead(pin);
    if(sensor == LOW)
  {
  led_state = !led_state;
  digitalWrite(led, led_state);
  delay(300);
  }

}

Módulo rfid MFRC522 + ARDUINO + LCD 16x2 I2C

2016-08-14T10:31:00.000-07:00

Nesse exemplo o primeiro cartão é lido e seu número de série é armazenado em uma variável.
Depois ao aproximar um cartão, este é lido e seu número é comparado com o número armazenado. Se forem iguais mostra a mensagem " ACESSO LIBERADO" caso contrário mostra "ACESSO NEGADO".
Como é um programa teste não me preocupei em armazenamento não volátil do número de série do cartão valido. Para uso real será necessário, pro exemplo, alterar o código para armazenar o número de série do cartão "válido" na memoria eprom do arduino.

Material utilizado:

Módulo RFID MFRC522 (datasheet)
Arduino UNO (foi usado um similar)
Display LCD 16x2 com módulo I2C.
Jumpers

Ligação:

Código:

/* adaptado do codigo que acompanha a biblioteca MFRC522:
https://github.com/ljos/MFRC522

Este exemplo armazena o numero primeiro cartão lido em uma variavel
A partir ao aproximar um catão é feita a comparação entre o valor lido do cartão e o valor armazenado.
As informações são mostrada em um display 16x2 via comunicação I2C.
*/

// bibliotecas
#include <SPI.h>  // padrão do arduino
#include <MFRC522.h>  // necessário adicionar na pasta libraries do arduino
#include <Wire.h> // padrão do arduino
#include <LiquidCrystal_I2C.h> // necessário adicionar na pasta libraries do arduino

LiquidCrystal_I2C lcd(0x27,16,2);
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);    // cria uma intancia MFRC522 com o nome mfrc522

int *aux;
int card1[4];
int flag = 0;
int led = 13;
int cnt =0;

void setup() {
        pinMode(led, OUTPUT);
        
        lcd.init();
        lcd.backlight();
    SPI.begin();        // Init SPI bus
    mfrc522.PCD_Init();    // Init MFRC522 card
        lcd.print(" Aproxime o card");
        lcd.setCursor(0,1);
        lcd.print(" Para registro  ");
}

void loop() {
    // Look for new cards
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }

    // Select one of the cards
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }

    // Now a card is selected. The UID and SAK is in mfrc522.uid.
    
    // Dump UID
    
    for (byte i = 0; i < mfrc522.uid.size; i++) {
            aux[i]= mfrc522.uid.uidByte[i];
    } 
           if(flag == 0)
           {
             lcd.clear();
             lcd.print("   Card UID:    ");
             lcd.setCursor(0,1);
             for (byte i = 0; i < mfrc522.uid.size; i++) {
               card1[i] = aux[i];
             lcd.print( card1[i], DEC);
             lcd.print( " ");
             flag =1;
            }
           delay(3000);
           lcd.clear();
           lcd.print(" Aproxime o card");
           lcd.setCursor(0,1);
           lcd.print("  Para Acesso   ");
           } 

           else{
            
           
             for (byte i = 0; i < mfrc522.uid.size; i++) {
               if(aux[i] == card1[i])
                cnt++;
             }
                            
            if(cnt == mfrc522.uid.size-1)
            {
              lcd.clear();
              lcd.print("     ACESSO     ");
              lcd.setCursor(0,1);
              lcd.print("   PERMITIDO    ");
              delay(2000);
             }
             else
             {
              lcd.clear();
              lcd.print("     ACESSO     ");
              lcd.setCursor(0,1);
              lcd.print("     NEGADO     ");
              delay(2000);
             }
             
           }
           
           lcd.clear();
           lcd.print(" Aproxime o card");
           lcd.setCursor(0,1);
           lcd.print("  Para Acesso   ");
  cnt=0;
}

Módulo relé de 4 canais como ponte H dupla

2016-08-02T12:09:00.001-07:00

Uma solução simples e ecomímica, para controle de dois motores de corrente continua é o modulo relé de 4 canais. Com ele é possível controlar o sentido de rotação de dois motores o suficiente para construir um robô com três rodas, duas de tração e um rodizio, por exemplo, com controle de direção. O "porém" do modulo relé é que não é possível controle de velocidade sem o uso de um transistor de potencia ou um mosfet adicional.

Um exemplo de modulo rele 4 canais (4 relés). Ele possi 4 relé de 1 polo x 2 posições:

Exemplo de modulo relé 4 canais. Nesse caso 5V

Ponte H

Em um motor de Corrente contínua invertendo a polaridade da alimentação em seus terminais:

Na ponte H essa caracteristica é aproveitada para controlar do sentido de rotação desses motores

Para facilitar a compreensão considere que montaremos um carrinho com parte de tração como a figura abaixo:

Usaremos o arduino como elemento principal de controle:

O primeiro passo é fazer as ligações necessárias no modulo relé 4 canais para que ele seja utilizado como duas pontes H:

Em seguida ligar os motores. Nesse primeiro momento sem se preocupar com a polarização:

O próximo passo é ligar parcialmente ao arduino para ajustar o sentido de rotação. Nessa etapa não é necessário programa rodando no Arduino:

Ligar como acima sem se preocupar com programação do arduino para ajustar o sentido de rotação nos motores. Por exemplo o sentido indicado na ilustração acima que serve para uso em um robô. Consideremos que girar nesse sentido faz o robô ir para frente.

Se ao ligar o sentido de rotação não for o indicado na figura basta inverter os foi de ligação do motor com giro errado. No desenho acima os fios verdes

Após os testes, completar as ligações com o arduino:

O código para teste é bastante simples. Segue abaixo comentado. As funções "frete", "re", "direita", "esquerda" e "parar" podem ser aproveitadas para qualquer projeto dessa natureza. Um detalhe importante sobre o módulo que esta sendo usado é que ele deve receber sinal de nível baixo (0V) em um dos pinos IN1, IN2, IN3 ou IN4 para acionar o relé correspondente.

/* funçao teste carrinho:

vai para frete por 2 segundos
vai para tras pro 2 segundos
vai para esquerda por 2 segundos
vai para a direita por 2 segundos
para por 2 segundos
pra repetir é necessario pressionar o botão reset do arduino

*/

int IN1= 5;
int IN2= 4;
int IN3= 3;
int IN4= 2;

void setup() {

  //declara pinos como saida
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);


// chama a funçao frete passando parametro em milesegundos
// anda para frete por 2 segundos
frete(2000); 


// anda para traz por 2 segundos 
re(2000); 

// vira para direita por 2 segundos 
direita(2000); 

// anda para esquerda por 2 segundos 
esquerda(2000); 


// Para por 2 segundos
parar(2000); 

}

void loop() {
// como deve execultar uma apenas uma vez para teste a funçao loop esta vazia
// o programa foi colocado na funçao setup
}



// função frente
void frete(int tmp)
{
 
   // MOTOR ESQUERDO FRETE
 digitalWrite(IN1,HIGH);
 digitalWrite(IN2,LOW);
 
  // MOTOR DIREITO FRETE
 digitalWrite(IN3,HIGH );
 digitalWrite(IN4,LOW);

 delay(tmp);

}


// função re
void re(int tmp)
{

  // MOTOR ESQUERDO RE
 digitalWrite(IN1,LOW);
 digitalWrite(IN2,HIGH);
 
  // MOTOR DIREITO RE
 digitalWrite(IN3,LOW);
 digitalWrite(IN4,HIGH);

 delay(tmp);

}

// função esquerda
void esquerda(int tmp)
{

   // MOTOR ESQUERDO RE
 digitalWrite(IN1,LOW);
 digitalWrite(IN2,HIGH);
 
  // MOTOR DIREITO FRETE
 digitalWrite(IN3,HIGH );
 digitalWrite(IN4,LOW);

 delay(tmp);

}


// função direita
void direita(int tmp)
{

   // MOTOR ESQUERDO FRENTE
 digitalWrite(IN1,HIGH);
 digitalWrite(IN2,LOW);
 
  // MOTOR DIREITO RE
 digitalWrite(IN3,LOW);
 digitalWrite(IN4,HIGH);

 delay(tmp);

}


// função parar
void parar(int tmp)
{

   // MOTOR ESQUERDO PARADO
 digitalWrite(IN1,HIGH);
 digitalWrite(IN2,HIGH);
 
  // MOTOR DIREITO PARADO
 digitalWrite(IN3,HIGH);
 digitalWrite(IN4,HIGH);

 delay(tmp);

}

Arduino + sensor digital de luminosidade BH1750FV + LCD I2C

2014-08-03T14:36:00.000-07:00

O sensor BH1750FV é um senso digital de luminosidade com comunicação I2C.

Sua utilização é bastante simples pois, oferece em sua saída o valor pronto para uso em Lux dispensando cálculos e calibrações.

As características básicas são:

>> Tensão de alimentação: 3V-5V;

>> Faixa de medição: 0-65535 lux;

>> Conversor adc integrado: 16 bits;

>> Saída digital direta dispensa cálculos complexos ou calibração;

>> Dois endereços possíveis. Permitindo a ligação de dois módulos no mesmo microcontrolador:

0x5C (pino ADD em nível alto) e 0x23 (pino add em nível baixo, padrão).

Ligações para o exemplo do vídeo:

O código exemplo abaixo é uma adaptação para display I2C do código que acompanha a biblioteca para arduino disponibilizada por Genotronex em: https://github.com/Genotronex/BH1750FVI_Master

A biblioteca LCD_I2C também é utilizada.

 /*
Adaptação para display 12c por MelquíadesJR do código escrito por Mohannad Rawashdeh 
como exemplo da biblioteca: https://github.com/Genotronex/BH1750FVI_Master

  VCC >>> 3.3V
  SDA >>> A4 
  SCL >>> A5
  addr >> A3
  Gnd >>>Gnd
 
 */
 
 // Bibliotecas:
 #include <BH1750FVI.h> // biblioteca do sensor
 #include <Wire.h> // biblioteca I2C
 #include <LiquidCrystal_I2C.h>  // biblioteca para o display lcd
 LiquidCrystal_I2C lcd(0x27,16,2);
 
 uint16_t Light_Intensity=0;

 BH1750FVI LightSensor;  //instancia o sensor
 
void setup() {

  lcd.init();  // inicializa o lcd 
  lcd.backlight(); // acende o backlight do lcd 
 
  LightSensor.begin(); // inicializa o sensor 
  //endereço I2C 0x23 (Device_Address_L para endereço 0x5C)
  LightSensor.SetAddress(Device_Address_L); 
  LightSensor.SetMode(Continuous_H_resolution_Mode);

  lcd.setCursor(0, 0);
  lcd.print("BH1750 Sensor");
  lcd.setCursor(1, 1);
  lcd.print("Inciando..."); 
  delay(2000);
  lcd.clear();
 lcd.print(" Luminosidade:   ");
}
 
 void loop() {
   
   lcd.setCursor(5, 1);
   lcd.print("      ");
   lcd.setCursor(5, 1);
   Light_Intensity = LightSensor.GetLightIntensity();
   lcd.print(Light_Intensity);
   lcd.setCursor(10, 1);
   lcd.print("Lux");
   delay(500);
   
  
}

Arduino TCS3200D Sensor de cor RGB

2012-12-16T17:02:00.001-08:00

O TCS3200D é um sensor estático de cor. Ele possui 16 foto transistores com filtro Vermelho (R), 16 com filtro Verde (G), 16 com filtro para azul(B) e 16 sem filtro (branco). Os filtros impedem a passagem das demais cores permitido que o fototraisistor seja excitado apenas pela luz quista. Através de dois pinos é possível selecionar qual grupo de fototransistor estará ativo e consequentemente qual luz será captada pelo sensor. A saída do sinal no sensor em uma onda quadra com frequência proporciona a intensidade da cor medida R, G, B, W.

O sensor

Como mencionado na introdução o sensor é basicamente constituído por quatro grupos de fototrasistores três desses grupos com filtros.

Os fototransistores são simplificadamente, transistores cujas bases são expostas. A incidência de luz sobre a base faz com que o transistor conduza. A variação dessa luz provoca variação proporcional na corrente que circula no fototransistor até o limite de saturação. Colocando um filtro que só deixe passar luz vermelha, por exemplo, apenas a luz vermelha fara conduzir o fototransistor. Então a corrente que circula no fototransistor será função da luz vermelha sobre ele.

É isso que ocorre no sensor, Um grupo de sensores não tem filtro algum o que o torna sensível a toda luz que incida sobre ele e cada um dos três outros grupos de sensores é dotado de filtro para uma determinada cor de luz vermelho, verde e azul.

Através dos pinos S2 e S3 é possível selecionar qual grupo de fototransistores estará ativo e consequentemente qual luz o sensor estará medindo e mostrando em sua saída. A tabela ao lado mostra as combinações destes pinos e o respectivos sensores selecionados.

Outra possibilidade de configuração do sensor é escalonar a frequência de saída escolhendo através dos pinos S0 e S1. A tabela ao lado mostra as combinações destes pinos e as respectivas escalas.

Recebendo os dados do sensor

A saída do sensor e uma onda com frequência diretamente proporcional a intensidade da cor medida naquele instante. Queremos obter a frequência em ciclos por segundo. Como se trada de uma onda quadrada com "duty cicle" de 50% (metade do ciclo em nível alto e metade em nível baixo). Então o programa deve contar todos os ciclos que ocorrem em um segundo. Ou estimar contando por 1/2 segundo e multiplicando por 2.

Uma forma de contar os ciclos para determinar a frequência é usando uma interrupção externa e um timmer o timer é setado para um segundo, por exemplo, e durante esse tempo uma variável é incrementada toda vez que a saída do sensor ligada ao pino de interrupção correspondente sai do nível baixo para o alto.

Para receber os dados do sensor deve-se selecionar o filtro através de S1, S2, S3 e S4 conforme a tabela abaixo e receber e decodificar a informação sobre a cor selecionada através do pino OUT.

O programa para o arduino mostrado abaixo foi adaptado do programa encontrado neste site. usa a solução timme e interrupção externa. O programa para processing foi escrito suando como base o exemplo que acompanha a IDE do arduino "Arduino call response". Na primeira leitura o programa ajusta o balanço de branco, por isso é importante expor o sensor a referência de branco ao iniciar o arduino. No vídeo eu coloco uma folha em branco sobre o sensor ao iniciar o arduino para ter esta referência.

Código para o Arduino:

// este codigo e uma adaptação do coodigo encontrado em:
//http://www.elecfreaks.com/1666.html

//é necessario a biblioteca Timer1 que pode ser baixada aqui:
//http://www.arduino.cc/playground/Code/Timer1
// baixe renomei-a para TimerOne e adcione-a na pasta libriries da ide do arduino

#include <TimerOne.h>

#define OUT  2
#define S2   5
#define S3   6
#define S0   3
#define S1   4

volatile int g_count =0;
int g_flag = 0;
int g_array[3] = {0};
float g_SF[3] = {0};

void setup()
{
  // Init TSC230 and setting Frequency.
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(OUT, INPUT);

  digitalWrite(S0, LOW);  // OUTPUT FREQUENCY SCALING 2%
  digitalWrite(S1, HIGH);
  
  Serial.begin(115200);
  Timer1.initialize();             // defaulte is 1s
  Timer1.attachInterrupt(TSC_Callback);
  attachInterrupt(0, TSC_Count, RISING);

  delay(4000);

  g_SF[0] = 255.0/ g_array[0];     //R Scale factor
  g_SF[1] = 255.0/ g_array[1] ;    //G Scale factor
  g_SF[2] = 255.0/ g_array[2] ;    //B Scale factor

  estabeleceContato(); // aguarda contato com o processing
}
void loop()
{
   g_flag = 0;
   for(int i=0; i<3; i++)
   {
   int val = int(g_array[i] * g_SF[i]);
   val = constrain(val, 0, 255);
   Serial.write(val);
   }
   delay(4000);

}

// seta o filtro
void TSC_FilterColor(int Level01, int Level02)
{
  if(Level01 != 0)
    Level01 = HIGH;

  if(Level02 != 0)
    Level02 = HIGH;

  digitalWrite(S2, Level01);
  digitalWrite(S3, Level02);
}
// incrementa g_cont cada vex que a sáida do sensor
// vai do nivel baixo ao alto
void TSC_Count()// finção chamada pela interrupção
{
  g_count ++ ;  // incrementa g_cont
}

void TSC_Callback()
{
  switch(g_flag)
  {
    case 0:
          TSC_WB(LOW, LOW);     //Red
         break;
    case 1:
         g_array[0] = g_count;
         TSC_WB(HIGH, HIGH);    //Green
         break;
    case 2:
         g_array[1] = g_count;
         TSC_WB(LOW, HIGH);     //Blue
         break;
    case 3:
         g_array[2] = g_count;
         TSC_WB(HIGH, LOW);     //Clear(no filter)
         break;
   default:
         g_count = 0;
         break;
  }
}

void TSC_WB(int Level0, int Level1) //balanceamento de branco
{
  g_count = 0;
  g_flag ++;
  TSC_FilterColor(Level0, Level1);
  Timer1.setPeriod(1000000);    // define periodo de 1 segundo
}

 void estabeleceContato() {
    while (Serial.available() <= 0) {
    Serial.write('A');   // envia A ate estabelecer contato
    delay(300);
  }
 }

Código para o Processing:

// Adaptado do exemplo SerialCallResponse que acompanha a IDE do Arduino

import processing.serial.*;

 int comando =0;
 int y_01 = 55;
 
Serial myPort; // porta serial
int[] serialInArray = new int[3]; // vetor para armazenar o valores recebidos
int serialCount = 0;           // usado para contar o numero de bytes recebidos

int[] buffer = new int[3];

boolean firstContact = false;  // Whether we've heard from the microcontroller

void setup() {
  // imprime a lista de portas seriais
  println(Serial.list());

  String portName = Serial.list()[0];
  // substituir COM9 pela porta onde esta o Arduino
  myPort = new Serial(this, "COM9", 115200); 
  size(800, 600);  //janela, largura, altura
  smooth();
  
}

void draw() {

 
    background(buffer[0],buffer[1],buffer[2]);      
    
}


void serialEvent(Serial myPort) {
  
  // le os bytes da porta serial
  int inByte = myPort.read();
  // se receber o primeiro byte e for 'A'
  if (firstContact == false) {
    if (inByte == 'A') { 
      myPort.clear();       // Limpa o buffer da porta serial
      firstContact = true;  // o primeiro contato ja ocorreu
      myPort.write('A');    // envia "A" para que o arduino 
                            // reconheça o primeiro contato
    } 
  } 
  else {
    // se não for o primeiro byte adiciona-o ao vetor:
    serialInArray[serialCount] = inByte;
    serialCount++;

    // quando receber os 12 bytes armazena-os em buffer[i]
    if (serialCount > 2) {
      for(int i =0; i<3; i++)
      {
      buffer[i] =  serialInArray[i];
      }       
        // envia comandos caso existam
      myPort.write(comando);
      // Reset serialCount:
      serialCount = 0;
    }
  }
}

Arduino sensor de toque humano

2012-09-08T12:15:00.000-07:00

Tenho garimpado alguns sensores no ebay e outros sites do gênero. O problema e que muitos sensores colocados à venda têm pouca ou nenhuma documentação disponível na internet. É preciso usar de engenharia reversa pra entender seu funcionamento e usá-los bem. Esta postagem mostra um desses sensores o sensor de toque humano.

Este sensor usa o comparador LM393 e tem como elemento sensor um transistor darligton MPSA13. O segredo é que a base do transistor não está ligada a nada, fica enrolada no corpo do transistor onde pode ser tocada. Ao tocar a base o transistor conduz o que através do LM393 coloca a saída digital do sensor (SD) em nível alto. Nos meus testes a saída ficou oscilando entre nivela alto e baixo quando o sensor era tocado. Foi preciso considerar isso na hora de programar.

O sensor também possui uma saída analógica (SA), direto do elemento sensor sem passar pelo comparador. Se ligada a uma entrada analógica do arduino, por exemplo, teremos um valor entre 1023 e 0. Na pratica, ao tocar no sensor o valor salta rapidamente de próximo do 1023 a próximo do 0. Um dos testes que fiz foi usar um pequeno pedaço de fio, como antena, conectado à base do transistor para aumentar sensibilidade. Nestes testes aproximar a mão de antena fazia aumentar o valor lido da saída analógica do sensor.

No experimento mostrado no vídeo a saída digital foi ligada no pino digital 3 do arduino. O comportamento seria idêntico ao de um botão se não fosse pelo fato da saída varia entre o nível alto e baixo, varias vezes por segundo, quando há o toque no elemento sensor. Para minimizar o esse efeito foi usado um laço. Enquanto a saída está em nível baixo o programa permanece nesse laço. Uma pequena mudança da saída para o nível alto faz o programa sair do laço e alterar o estado do pino 13 que, por sua vez controla o acendimento da lâmpada.

Programa

const int sensorPin = 3;
const int ledPin =  13;     

int sensorState = 0;        
int sensorState_aux = 0;    

void setup() {
  pinMode(ledPin, OUTPUT);      
  pinMode(sensorPin, INPUT);     
}

void loop(){

  sensorState_aux = digitalRead(sensorPin);
  delay(30);
  
  // sem ser tocado a saida do sensor permanece em nivel baixo
  // quand tocado a saída alterna entre nível baixo e alto
  // para eviatar ocilacões aguarda a saída ir ao nivel alto
  while( sensorState_aux != HIGH) 
  {
  sensorState_aux = digitalRead(sensorPin);
  delay(30);
  }
  //inverte o estado aterior do pino 13 do arduino
  // se HIGH passa para LOW e vice-versa
  sensorState = !sensorState;
  
  if (sensorState == HIGH) {     

    digitalWrite(ledPin, HIGH);  
  } 
  else {

    digitalWrite(ledPin, LOW); 
  }
   delay(500);
}

Motorizando patinete infantil

2012-08-11T15:59:00.000-07:00

Uma postagem anterior mostrava a motorização de um carrinho de criança usando um motor de vidro elétrico, um ESC com relés tendo como "celebro" um PICAXE 08M, veja aqui. Desta vez o alvo é uma patinete da Barbie, brinquedo de minha filha de cinco anos. O motor usado, bem como as adaptações feitas no conjunto motor redutor são as mesmas do carrinho. Como não há necessidade de ré os relés foram dispensados. A placa, usada para controlar a velocidade tem basicamente o Picaxe, um mosfet e um regulador de voltagem.

Adaptação mecânica

Algumas modificações foram feitas. O eixo traseiro foi substituído por uma barra roscada de 3/8”. Essa barra passo por dentro da engrenagem centrar do conjunto motor redutor. Assim como no carrinho a barra é presa no motor e nas rodas com uso de porca e contra porca. Dois pequenos pedaços de tubo de PVC 1/2" foram usados para afastar as rodas da patinete. Foi feito um furo na parte traseira para que fosse possível abrigar a placa de controle no interior da patinete e prender o motor com auxilio de uma abraçadeira feita de chapa de alumínio.

Parte eletroeletrônica

Ao lado é possível ver o diagrama do circuito usado para controlar a velocidade de rotação o motor. O acelerador está representado como um potenciometro mas, na verdade, não sei o que ele realmente tem dentro. Consegui usa-ló depois de alguns testes. Dois pinos do PICAXE 08M são usados, uma como entrada analógica para o acelerador e outro como saída PWM para o mosfet, que aciona o motor. Um acoplador ótico é usado entre o picaxe e o mosfet. A placa ainda possui um regulador de voltagem 7805 responsável pela alimentação do PICAXE (5V).

O programa

O programa é extremamente simples Nele o picaxe lê o valor do acelerador através de uma entrada analógica. Vale ressaltar que o acelerador usado aqui quando na posição de descano envia um valor maior que zero. Depois de alguns testes percebeu-se que 250 seria o valor suficiente para garantir que a patinete permanecesse parada quando não houvesse acionamento do acelerador. Quando o valor é menor que 250 o programa mantém o motor parado. Quando o valor lido é maior que 250 esse valor e usado para gerar o PWM que será aplicado ao motor através do pino 2.

symbol acel_value = w1

symbol motor_pin =  2

main: 'loop principal

' le o valor do acelerador no pino 4 e armazena
' em acel_value (w1)

READADC10 4, acel_value  

'se o valor for menor que 250 mantem o motor parado

if acel_value < 250  then 

pwmout motor_pin,255,0

'se o valor for maior que 250 aplica-o (PWM) ao motor

else

pwmout motor_pin,255,acel_value

endif

goto main 'fim do loop principal

Arduino LDR matriz

2012-08-07T15:03:00.000-07:00

Dada a impossibilidade de usar uma câmera como sensor no arduino, pensei na possibilidade de construir uma espécie de CCD de muito baixa resolução, utilizando LDRs. Pesquisando na internet encontre este site com um excelente trabalho na criação de uma mesa com 64x64 LDRs. Decidi então construir uma pequena matriz, 3x4, para testes.

O LDR (Light Dependent Resistor) como o próprio nome sugere é um resistor que tem sua resistência variada em função da luz que incide sobre ele. Quanto maior a luz menor a resistência. Se ligado a uma entrada analógica do arduino tem-se um valor proporcional à luz que incide sobre o LDR teoricamente entre 0 e 1024.

A ideia principal é ler através da porta analógica do Arduino cada LDR e enviar esses valores ao processig que, pro sua vez usa estes valores para determinas o tom de cinza de um retângulo formado por doze quadrados, cada um corresponde ao LDR na mesma posição.

Ao lado é mostrado o diagrama dos LDRs e uma animação que ilustra como a leitura é feita na matriz. Coloca-se o pino 2 em nível alto e procede a leitura das entradas analógicas A0, A1, A2 e A3 armazenado os valores nas variáveis correspondentes ao primeiro, segundo, terceiro e quarto LDRs o mesmo acontece na segunda linha, pino 3, LDRs cinco a oito e na terceira linha, pino 4. LDRs nove a doze.

A montagem foi feita em uma placa perfurada padrão. Os diodos são 1N4148, mas podem ser substituídos por equivalentes. Eles são responsáveis em garantir que um LDR não interfira na leitura de outro. Os resistires são de 10 kohm.

Os programas foram baseados no exemplo SerialCallResponse que acompanha a IDE do Arduino. O exemplo ensina como enviar bytes do arduino a processing e do processing ao arduino. No programa abaixo o arduino envia 12 bytes, um para cada valor lido nos LDRs. Antes de ser enviado o valor é ajustado para um valor entre 0 e 255. O processing recebe os bytes e usa-os para determinar o tom de cinza do quadrado correspondente.

Programa para o arduino:

 const int ldr[4] = {A0, A1, A2, A3};  
 const int vccPin[3] = {2,3,4};  
 int ldrValue;  
 void setup() {  
  Serial.begin(19200);  
  pinMode(vccPin[0], OUTPUT);   
  pinMode(vccPin[1], OUTPUT);   
  pinMode(vccPin[2], OUTPUT);   
  estabeleceContato(); // Envia um byte "A" ate obter resposta do processing   
 }  
 void loop() {  
   for(int i = 0; i < 3; i++)  
   {  
    digitalWrite( vccPin[i],HIGH);  
      for(int j = 0; j < 4; j++)  
      {  
       ldrValue = analogRead(ldr[j]);  // le o LDR correspondente  
       ldrValue = constrain(ldrValue, 0, 800); // ajusta valor lido  
       ldrValue = map(ldrValue,0,800,0,255);  // ajusta valor lido  
       Serial.write(ldrValue); // envia valor via porta serial   
      }  
    digitalWrite( vccPin[i],LOW);  
   }           
 } // fim do loop principal  
 void estabeleceContato() {  
   while (Serial.available() <= 0) {  
   Serial.write('A');  // envia A ate estabelecer contato  
   delay(300);  
  }  
  }

Programa para o Processing:

 // Adaptado do exemplo SerialCallResponse que acompanha a IDE do Arduino  
 import processing.serial.*;  
  int comando =0;  
  int y_01 = 55;  
 Serial myPort; // porta serial  
 int[] serialInArray = new int[12]; // vetor para armazenar o valores recebidos  
 int serialCount = 0;      // usado para contar o numero de bytes recebidos  
 int[] buffer = new int[12];  
 boolean firstContact = false; // Whether we've heard from the microcontroller  
 void setup() {  
  // imprime a lista de portas seriais  
  println(Serial.list());  
  String portName = Serial.list()[0];  
  // substituir COM9 pela porta onde esta o Arduino  
  myPort = new Serial(this, "COM9", 19200);   
  size(800, 600); //janela, largura, altura  
  background(0);  
  smooth();  
 }  
 void draw() {  
   stroke(255); // borda   
   fill(buffer[0]);    // determina a cor     
   rect(0, 0, 200, 200); // desenha o quadrado 1  
              // posicao x, posicao y, largura , altura  
   fill(buffer[1]);     
   rect(200, 0, 200, 200);   
   fill(buffer[2]);     
   rect(400, 0, 200, 200);    
   fill(buffer[3]);      
   rect(600, 0, 200, 200);    
   fill(buffer[4]);      
   rect(0, 200, 200, 200);   
   fill(buffer[5]);       
   rect(200, 200, 200, 200);    
   fill(buffer[6]);    
   rect(400, 200, 200, 200);  
   fill(buffer[7]);     
   rect(600, 200, 200, 200);  
   fill(buffer[8]);        
   rect(0, 400, 200, 200);   
   fill(buffer[9]);         
   rect(200, 400, 200, 200);  
   fill(buffer[10]);     
   rect(400, 400, 200, 200);  
   fill(buffer[11]);      
   rect(600, 400, 200, 200);   
 }  
 void serialEvent(Serial myPort) {  
  // le os bytes da porta serial  
  int inByte = myPort.read();  
  // se receber o primeiro byte e for 'A'  
  if (firstContact == false) {  
   if (inByte == 'A') {   
    myPort.clear();    // Limpa o buffer da porta serial  
    firstContact = true; // o primeiro contato ja ocorreu  
    myPort.write('A');  // envia "A" para que o arduino   
               // reconheça o primeiro contato  
   }   
  }   
  else {  
   // se não for o primeiro byte adiciona-o ao vetor:  
   serialInArray[serialCount] = inByte;  
   serialCount++;  
   // quando receber os 12 bytes armazena-os em buffer[i]  
   if (serialCount > 11) {  
    for(int i =0; i<12; i++)  
    {  
    buffer[i] = serialInArray[i];  
    }      
     // envia comandos caso existam  
    myPort.write(comando);  
    // Reset serialCount:  
    serialCount = 0;  
   }  
  }  
 }

Robô de sumô 500g

2012-07-12T19:47:00.001-07:00

O robô mostrado aqui foi construído para participar de campeonato de sumô de robôs na categoria quinhentas gramas. Neste tipo de competição o robô deve mover-se dentro de uma arena preta com bordas brancas procurando seu oponente para empurra-lo para fora da arena. Na categoria do Eniac Jr., como foi batizado, além de não poder pesar mais que quinhentos gramas, o robô não deve ter largura e comprimento superiores a 10 cm.

A estrutura

A estrutura é composta basicamente por duas placas de compensado 4 mm e quatro pedaços de barra roscada de 4mm de diâmetro e 9cm de comprimento. Na primeira plataforma (8cm x 6 cm) estão os servo motores, presos por abraçadeiras, e os sensores de linha. Na segunda (10cm x 8 cm), o arduino com uma sensorshield, que é a placa sobre o arduino, usada para facilitar a conexão dos sensores e servos, o UBEC (regulador 5V x 5A), é necessário pro que os servos são forçados e não é conveniente alimenta-los diretamente pelo arduino. O sensor de oponente e demais componentes eletrônicos também estão na segunda plataforma.

Apenas duas rodas são usadas. Foram adaptadas do rolo de tração de uma velha impressora. Uma pequena chapa de alumínio substitui a roda frontal.

A eletrônica

Sensor de linha

Os motores usados são servomotores modificados para rotação. Usar servos trás a vantagens deles já possuirem circuito de acionamento interno, necessitando apenas do sinal de controle e alimentação que neste caso e de 5 V/ 5A, provida por um UBEC (Universal Battery Eliminator Circuit). A bateria usada é uma LIPO 3 células 1300 mAh.

Sensores

O Eniac Jr possui quatro sensores. Tanto os dois sensores de linha frontal quanto o sensor de linha traseira, que não está sensdo usado por ainda não ser necessário no programa, foram montados conforme digrama ao lado.

O quarto sensor é usado para detectar o oponente. Trada-se de um sensor infravermelho sharp GP2Y0A21. Um excelente sensor para este tipo de aplicação por sua velocidade e facilidade de uso.

O microcontrolador

Para controlar o robô foi escolhido o arduino, uma plataforma excepcional por sua capacidade, versatilidade e enorme quantidade de material de consulta. Este projeto está usando o arduino Uno, equipado com o atmega 328, o mais comumente usado hoje. Talvez fosse melhor usar o arduino mini 3.0 por seu tamanho reduzido.

O código fonte que embarca o arduino pode ser visto, com comentários, abaixo. É um programa básico pretendo incrementa-lo. A dinâmica de funcionamento é a seguinte:

Depois de ligado o robô aguada cinco segundos e inicia seu funcionamento andando para frete. Caso encontre a linha branca retorna e gira em torno de si mesmo procurando o oponente com auxilio do sensor frontal. Se encontrar o oponente o robô para de girar e volta a andar para frete. Não encontrando o adversário ele anda para frente após o fim do tempo de procura.

  #include <Servo.h>  
  Servo esquerdo;   
  Servo direito;   
  //******************* PINOS **********************//  
  int direito_pin = 10;  
  int esquerdo_pin = 11;  
  int SLF_esq = 8;  // pino do sensor de linha frontal esquerdo  
  int SLF_dir = 9;  // pino do sensor de linha frontal direito  
  int led_pin = 13;  // led no pino 13  
  int sens_front = 5; // pino do sensor oponente frontal (SHARP)( pino analogico 0 )  
 //****************** VARIAVEIS ******************//  
  long cm;    // variaveis para sensor frontal  
  float sharp = 0;  // usada na leitura dos sensores analogicos  
  float distancia = 0; // usada na leitura dos sensores analogicos  
  int tmp_Re = 5;  // tempo de reversão dos motores quando o robo encontra a linha*200 milissegundos  
  int tmp_Busc =3.4; // tempo de procura do adverssario, girando, em segundos  
  long raio_front = 35; // raio de procura frontal em centimetros  
  long tmpRound = 90000;  // tempo do round 90.000 milissegundos. 1 minuto e 30 segundos  
  long prev_tmpRound;  // variavel para contar tempo do round  
  unsigned long current_tmpRound; // variavel para contar tempo do round  
  long previousMillis;  // variavel para contar tempo entre buscas  
  unsigned long currentMillis; // variavel para contar tempo entre buscas  
  int aux_SLF = 0; // auxiliar para leitura do sensor de linha frontal  
  int aux_SLT = LOW; //0; // auxiliar para leitura do sensor de linha traseiro  
  int aux_front = 0;  // auxiliar para leitura do sensor frontal  
 //**************** SETUP *****************************//  
 void setup() {   
  Serial.begin(19200);   
  pinMode(led_pin, OUTPUT);  
  pinMode(SLF_esq, INPUT);  
  pinMode(SLF_dir, INPUT);  
 // conta os cinco segundos piscando o led do pin 13  
  for(int conte = 0; conte < 5; conte++)   
  {  
   digitalWrite(led_pin, HIGH);  
   delay(300);  
    digitalWrite(led_pin, LOW);  
   delay(700);  
  }  
  esquerdo.attach(esquerdo_pin,1000,2000);  //servo1 no pino 2, min, max  
  direito.attach(direito_pin,1000,2000);  //servo1 no pino 3   
  prev_tmpRound = millis();  // prev_tmpRound recebe o tempo atua de execução do programa marcando a contagem do round  
  current_tmpRound = millis();  
  // procurar(); // inicia procurando o oponente  
 }  
 //***************** FIM SETUP ****************************//  
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  
  ///////////////////////////////////////////////FUNÇÃO PRINCIPAL///////////////////////////////////////////////////////////////////  
 void loop()   
 {  
  int a1 =0;  
  int proc = 0;  
  int cnt =0;  
  int cnt_tmp =0;  
  static int direcao = LOW;  
  frente();  
  aux_SLF = ler_digital(SLF_esq , SLF_dir); // verifica sensor frontal de linha ( HIGH para branco LOW para preto)  
 // aqui o robo comeca efetivamente seu trabalho andar no tatame a procurar o oponente   
 // ele para apos 90 segundos (tempo do round)  
  do    
  {     
   if(aux_SLF == HIGH) // se um dos sensores de linha dianteiros encontrou a linha branca  
    {  
      re();  
      while(cnt_tmp < tmp_Re*4)  
      {  
       delay(50);  
       cnt_tmp++;  
      }  
      cnt_tmp =0;  
      procurar();  
    }  
   else  
    {  
    frente(); //se nenhum dos sensores for acionado continua indo em frente  
    }  
     aux_SLF = ler_digital(SLF_esq , SLF_dir); // verifica sensor frontal de linha ( HIGH para branco LOW para preto)  
  current_tmpRound = millis(); // atualisa current_tmpRound com o tempo atua de execução do programa  
   }while(current_tmpRound - prev_tmpRound <= tmpRound);//O ROBO ANDA ATE SE PASSAR O TEMPO DE UM ROUND  
   parar(999999); // para o robo após fim do round  
 } // fim do void loop()  
 ///////////////////FUNÇÃO PARAR /////////////////////  
 // como a modificação dos servos não ficou 100% é dificil para-los totalmente  
 void parar(int time)  
 {  
   direito.write(92.5);  
   esquerdo.write(89.5);  
   delay(time);  
 }  
 ///////////////////FUNÇÃO FRENTE /////////////////////  
 void frente()  
 {  
   direito.write(0);  
   esquerdo.write(180);  
 }  
 ///////////////////FUNÇÃO RÉ /////////////////////  
 void re()  
 {  
   direito.write(180);  
   esquerdo.write(0);  
 }  
 ///////////////////FUNÇÃO DIREITA /////////////////////  
 void direita()  
 {  
   direito.write(180);  
   esquerdo.write(180);  
 }  
 ///////////////////FUNÇÃO ESQUERDA /////////////////////  
 void esquerda()  
 {  
   direito.write(0);  
   esquerdo.write(0);  
 }  
 ///////////////////FUNÇÃO ler sensores analogicos sharp/////////////////////  
 // adaptada de:  
 /* www.ebay.com/itm/5-x-Arduino-IR-Sensor-GP2Y0A21YK0F-Measuring-Detecting-Distance-  
 10-80cm-/261031972852?_trksid=p4340.m263&_trkparms=algo%3DSIC%26its%3DI%252BC%26itu%3DUCI%  
 252BIA%252BUA%252BFICS%252BUFI%26otn%3D15%26pmod%3D260944545770%26ps%3D63%26clkid%3D56665851  
 1840405440&_qi=RTM1062687 */  
 int ler_analog(int sensor, int raio)  
 {  
  sharp = analogRead(sensor);   
  distancia = (6762/(sharp-9))-4;  
  if(distancia <= raio)  
  {  
  digitalWrite(led_pin, HIGH);   
  return(HIGH); // retorna HIGH caso o opnente esteja dentro do raio de alcance definido  
  }  
  else  
  {  
  digitalWrite(led_pin, LOW);  
  return(LOW); // retorna LOW caso o opnente NÃO esteja dentro do raio de alcance definido  
  }  
 }  
 ///////////////////FUNÇÃO ler sensores digitais /////////////////////  
 int ler_digital(int sens1 , int sens2)  
 {  
  if(digitalRead(sens1) == LOW || digitalRead(sens2) == LOW)  
  return(HIGH);  
  else  
  return(LOW);  
 }  
 ////função procura oponete chamada depois que o robo encontra a linha e da re/////////////////////////////  
  void procurar()  
  {  
   int cnt1 =0;  
   int a =0;  
   static int direcao = LOW;  
   static int aux_sFront_ant = LOW;  
   static int aux_sFront = LOW;  
  previousMillis = millis();  
  currentMillis = millis();  
     aux_front = ler_analog(sens_front, raio_front); // verifica sensor procura frontal  
     aux_SLF = ler_digital(SLF_esq , SLF_dir); // verifica sensor frontal de linha ( HIGH para branco LOW para preto)  
  while(currentMillis - previousMillis <= (tmp_Busc * 1000) && aux_SLF != HIGH && aux_front != HIGH)  
  {  
   direita();  
   delay(30);  
  currentMillis = millis();  
  aux_front = ler_analog(sens_front, raio_front); // verifica sensor procura frontal  
  aux_SLF = ler_digital(SLF_esq , SLF_dir); // verifica sensor frontal de linha ( HIGH para branco LOW para preto)  
  }  
  }

delay x millis no Arduino

2012-05-15T20:05:00.000-07:00

A função delay é muito usada em programas para o arduino. É uma função simples e útil quando queremos pausa a execução de um programa pelo arduino.

O funcionamento dela é simples:

Imagine duas crianças brincando de esconder. A criança que conta deve ficar parada apenas contando até cem, por exemplo, para depois procurar a outra criança. A função delay(tempo e microssegundos) tem funcionamento similar o microcontrolado interrompe a execução do programa até o final do tempo determinado. Nem sempre é aceitável esperar o microcontrolador fazer a contagem de tempo através da função delay().

A função millis retorna o tempo de execução do programa até o momento em que ela é chamada. Como exemplo suponha que uma pessoa tem que falar por quinze minutos. Não seria possível contar e falar ao mesmo tempo então ela verifica a hora de inicio em um relógio e durante a palestra verifica novamente a hora subtrai a hora de inicio a fim de saber se já passaram os quinze minutos. Por exemplo, se a pessoa iniciou às 17h45min e olha o relógio às 17h55min saberá que ainda não passou 15 minutos, pois 17h55min - 17h45min = 10 minutos menor que 15. Mas se quando olhar para o relógio o palestrante e verificar que são 18h01min intenderá que é hora de parar já que 18h01min - 17h45min = 16 minutos que é obviamente maior que 15. Perceba que tanto faz verificar o tempo de inicio somar o tempo de duração do evento e verificar periodicamente se o tempo final resultante da soma já foi alcançado ou subtrair a cada período o tempo atual do tempo de inicio e comparar com o tempo de duração.

A função millis pode ser entendida como o relógio do exemplo acima. Sabendo-se que o programa começa a rodar no tempo 0 ms, se depois de um segundo chamarmos a função mills ela retornará 1000.

No programa abaixo, baseado no exemplo "Blink without Delay" que acompanha a interface de programação do arduino, enquanto aguardo o intervalo de um segundo entre as piscada do led no pino 13 o arduino imprime na tela do terminal "lendo sensor" o que poderia ser substituído por uma leitura real de um sensor ou outro tipo de ação.

int ledPin =  13;       // pino onde esta ligado o LED
int ledState = LOW;     // ledState usado para amazena o estado atual do led aceso o apagado
long intervalo = 1000;  // intervalo de um segundo
  
void setup() 
{
  pinMode(ledPin, OUTPUT); 
  Serial.begin(9600);      
}

void loop()
{
   long previousMillis = millis();
   int cnt=0;
   
    if (ledState == LOW)     // se o led estava apagado
        ledState = HIGH;    //
    else                   // se o led estava aceso
        ledState = LOW;   //

    digitalWrite(ledPin, ledState);
       
    // Mantem o led aceso ou apagado por um segundo
  while(millis() - previousMillis < intervalo) 
  {
       // pode-se fazer muita coisa dentro deste laço enquanto aguarda o final do tempo para mudar o estad do led
       // ler um sensor ou algo parecido, por exemplo
       if (cnt % 100 == 0)
       {
       Serial.print("Lendo sensor"); 
       Serial.print(" \n ");
       }
       cnt++;
  }

}

Arduino comando por voz

2012-04-06T08:49:00.001-07:00

-->

Um dia desses fuçando o Ebay encontrei um módulo de comando por voz baseado no CI SPCE061A. Ele é capaz de armazenar até 15 comandos divididos em 3 bancos de 5 comandos. No projeto descrito aqui foram gravados cinco comandos no banco "1" com a finalidade de controlar o acendimento, apagamento e frequência de piscada de uma lâmpada comum ligada ao pino 13 do arduino através de um módulo de força baseado em um triac.

A comunicação com o módulo é feita via interface serial. As mensagens de comando devem ser formadas pela chave 0xAA seguida do comando propriamente dito. Para gravar o banco um, por exemplo, basta envia via terminal o valor em 0xAA seguido do comando 0x11 (é sempre bom lembra que o "0x" informa que o número que o segue esta em hexadecimal) e, seguindo as mensagens de retorno no terminal ou observando os dois leds na placa, pronunciar e repetir cada um dos cinco comandos desejados para o banco em questão.

Após a gravação é possível acessar o banco 1 através do comando 0xAA + 0x21 que serve para importar o banco 01. Importar, neste caso, é ativar um determinado grupo de comandos, pois apenas um dos grupos pode estar ativo por vês. Isso faz com que o módulo compare o comando falado com os cinco gravados naquele banco.

O manual do modulo pode ser encontrado aqui. Ele é bastante completo inclusive indica um programa gratuito para

-->comunicação serial, o AccessPort que pode ser baixado aqui.

-->

Resumidamente para fazer funcionar o módulo com o arduino deve-se:

1. Selecionar a velocidade de comunicação serial enviando, por exemplo, o comando "AA34" para 19200bps ou "AA33" para 9600bps. Por padrão a velocidade é 9600;

2. Selecionar o modo de comunicação: modo comum ou compacto. O modo determina se o módulo irá responder aos comandos com respostas longas (mensagens) ou curtas (hexadecimal);

3. Iniciar a gravação de um dos três bancos enviando o comando correspondente "AA11" para gravar o banco um "AA12" para o dois ou "AA13" para o banco três.

-->

Ao iniciar a gravação do banco um, por exemplo, o módulo irá solicitar os cinco comandos de voz que deverão ser pronunciados e repetidos conforme mensagens de solicitação. Estes comandos de voz são associados a números. No banco um os números 0x11, 0x12, 0x13, 0x14 e 0x15 são associados aos comandos de voz um a cinco respectivamente. Sendo que o comando de voz um é o primeiro que foi gravado no banco e assim sucessivamente. Se um banco é ativado e o módulo recebe um comando de voz válido ele envia o valor correspondente via serial.

Quando um comando de gravação é enviado através do terminal, por exemplo, o modulo enviará um das seguintes respostas em hexadecimal ou em texto:

"ERROR! \ n" (0xe0)	Erro de instrução
"START \ n" (0x40)	Pronto para gravar
"No voice \ n" (0x41)	Não detectada voz
"Again \ n" (0x42)	Repita a instrução ( após proximo "START")
"Too loud \ n" (0x43)	Muito alto para gravar
"Different \ n" (0x44)	Repetição da instrução diferente da primera aguarde o START para repetir o comando de voz
"Finish one \ n" (0x45)	Uma instrução gravada com sucesso. O proximo START é para o comando de voz seguinte. Isso se repete até o quinto comando
"Group1 finished! \ n" (0x46)	Fim da gravação do grupo 1

-->É possível também acompanhar as mensagens através dos dois leds existentes no módulo. O que torna possível, por exemplo, gravar um banco comunicando-se com o modulo através do arduino sem o auxilio de um computador. Os detalhes para isso estão no manual.

-->

No programa, mostrado abaixo, o arduino inicializa o banco 1 e fica aguardando o comando enviado pelo modulo que por sua vez aguarda comandos de voz compatíveis com os gravados.

/*
 comandos de voz:
 
 1 - liga
 2 - desliga
 3 - pisca
 4 - mais
 5 - menos
 
 */

#include <Servo.h> 

long dist = 0;

int lampState = LOW;   

long previousMillis = 0;  
long intervalo = 1000; 
unsigned long currentMillis;

int lampada =13;
byte com = 0; 

void setup()
{
  

Serial.begin(9600);

pinMode(lampada, OUTPUT);

delay(2000);

// O modulo aceita comandos, em hexadecimal no seguinte formato:
// AA + comando 
Serial.write(0xAA); 
Serial.write(0x37); //configura o modulo para responder em modo compacto
delay(1000);        // no modo compacto as respostas são numeros em hexadecimal
Serial.write(0xAA);
Serial.write(0x21);//importa o grupo 1


}

void loop() // inicio do programa principal
{
  

while(Serial.available())
{
com = Serial.read();  //recebe o byte referente ao comando

if(com == 0x11) // ao recxeber o comando de voz "liga" o modulo envia o valor em hexadecimal: 11
digitalWrite(lampada, HIGH); // se receber 0x11 acende a lampada

if(com == 0x12) // ao recxeber o comando de voz "desiga" o modulo envia o valor em hexadecimal: 12
digitalWrite(lampada, LOW);// se receber 0x12 apaga a lampada

if(com == 0x13)// ao recxeber o comando de voz "pisca" o modulo envia o valor em hexadecimal: 13
{
 do  // se receber 0x13 entra neste laço que faz a lamada piscar. Aqui existem tres possibilidades:
     // Receber 0x14 "mais" e aumentar o intervalo entre as piscadas
     // Receber 0x15 "menos" e diminuir o intervalo entre as piscadas
     // Receber 0x11 (liga) 0u 0x12 (desliga) parar de piscar e fazer o que o comando pede
  {

   com = Serial.read();  //recebe o byte referente ao comando
    
     // piscar sem delay
       currentMillis = millis(); //armazena o valor referente ao tempo de execução do programa
        if(currentMillis - previousMillis > intervalo) 
         {   
          previousMillis = currentMillis;   

          if (lampState == LOW)
             lampState = HIGH;
          else
            lampState = LOW;

          digitalWrite(lampada, lampState);
         }
     //
    
    // se receber 0x14 aumenta o intervalo entre as piscadas   
    if(com == 0x14 && intervalo < 1000) 
    {
    intervalo +=100;
    }
    // se receber 0x14 diminue o intervalo entre as piscadas 
    if(com == 0x15 && intervalo > 100)
    {
    intervalo -=100;
    }
   
  // se receber 0x11 (liga) 0u 0x12 (desliga) para de piscar
  }while(com != 0x11 && com != 0x12);
}
}
}

ESC com relés e controle remoto 2.4 GHz em carro infantil

2011-12-22T18:19:00.000-08:00

-->

Minha filha mais nova tem um ano e meio. Comprei para ela um carrinho que tinha uns pedais péssimos de pedalar. Decidi remove-los e o carrinho ficou como o dos flintstones. Em seguida coloquei um lastro pra que ela apoiasse os pés e pudesse ser empurrada no carrinho. Depois resolvi colocar um motor com todos os acessórios necessários pra transformá-lo num carro elétrico. Por ultimo adaptei um controle remoto.

O controle remoto

-->

-->

O controle remoto 2,4 Ghz de três canais para carros. Na verdade eu montei o projeto baseado no controle remoto que eu já tinha em casa. Nada impede que seja usado um controle remoto mais simples tipo aqueles de carrinhos baratos 49Khz fazendo-se é claro as devidas alterações.

O ESC

O sinal de saída do receptor controla diretamente servomotores para controlar o motor da tração precisaria de um ESC (electronic speed control), controlador eletrônico de velocidade, tipo os usados em modelismo. O ESC recebe o sinal do receptor e o aplica através de uma etapa de potencia ao motor permitindo assim controlar a velocidade de rotação e, no caso dos carros também o sentido.

--> Como não tinha um ESC para motor escovado construí uma espécie de ESC com um microcontrolador picaxe 08M, dois relés, um mosfet e um punhado de outros componentes eletrônicos básicos. O diagrama pode ser visto ao lado.
O funcionamento é simples o picaxe, através da função pulsin lê o sinal do receptor como um valor que varia entre aproximadamente 100 e 200. O valor será zero caso o transmissor esteja desligado ou fora do alcance. Com a alavanca do controle no meio o valor lido pelo picaxe é de aproximadamente 150 devendo, neste caso, os dois reles serem desativados. Caso o valor seja menor que 145 o picaxe aciona o rele que faz o motor girar num determinado sentido que eu vou arbitrar como anti horário, apenas para facilitar o entendimento. Se o valor for maior que 155 o outro rele é acionado fazendo o motor girar no sentido horário. O sentido de rotação correto pode ser acertado pela alteração do programa, inversão dos terminais do motor ou pela inversão da ação no transmissor.

Estrutura e motor

-->

O motor usado é de vidro elétrico reaproveitado de um antigo robô lutador de sumo. Ele foi aberto e teve seu pino removido. Foi feito um furo na tampa metálica para permitir a passagem do eixo e um corte, com o auxilio de uma serra copo, no lado onde estava o pino de modo a deixar solto o guia do pino.

-->

Uma barra roscada foi adaptada no lugar do eixo traseiro (foto ao lado). Essa barra é presa ao conjunto engrenagem e antigo guia do pino por quatro porcas em contra pressão. O motor foi então preso ao carro com uma abraçadeira em alumínio.

-->

Para controlar a direção do carro foram usados dois servos ligados em paralelo, por um a extensão em 'Y', diretamente ao receptor do controle.

O pequeno código pode ser visto abaixo:

symbol frente_Pin = 1  ' pino para o rele frente
symbol re_Pin = 4  ' pino para o rele re
symbol pwm_pin = 2

main: 'laco principal

 'pwmout pwm_pin,255,555

'le  pulso no piuno 4 e armazena na palavra w0
    pulsin 3,1,w1
     
    
    'debug w1 'usado para testes
 
 ' se o controle estiver desligado e valor em w1 ser zero
 ' o carro deve ficar parado
if w1 = 0  then  

     low frente_Pin
     low re_Pin
   
 'se o valor lido for menor que 140 vai para frente
 else if w1 < 145 then
 
 'ajusta o valor de w1 para a escala do pwm

    w2 = 145-w1
    w2= w2 * 45/2
    
     pwmout pwm_pin,255,w2 ' aplica o pwm ao motor
     high frente_Pin 
     low re_Pin
     
 'se o valor lido for maior que 170 vai para traz      
 else if w1 > 155 then
 
 'ajusta o valor de w1 para a escala do pwm

    w2 = w1-155
    w2= w2 * 45/2
     
     pwmout pwm_pin,255,w2 ' aplica o pwm ao motor   
     high re_Pin
     low frente_Pi
     
 'se o valor lido for estiver entre 140 e 170 para o carro 
else

     low re_Pin
     low frente_Pin
 
 endif  

goto main ' retorna para main

Arduino cubo LED

2011-06-27T06:08:00.000-07:00

Cubo led não é nenhuma novidade, existem muitos tutoriais e vídeos na internet mostrando cubos 3x3x3, 4x4x4, 5x5x5, 8x8x8 e até maiores. Como me interessei pelo assunto há pouco tempo decidi começar com o 3x3x3 que é mais simples e barato apesar de, obviamente, ser mais limitado por ter menor definição.

Dois projetos postados no instructables me deram subsídio para montar meu primeiro cubo led : O 3x3x3 LED Cube (autor: portreathbeach) e o LED Cube 8x8x8 (autor: chr) . O primeiro é montado com pic. No post o autor disponibiliza um programa em VB que pode ser usado para gerar os bytes para acionamento do cubo. Para ser usado com o arduino é preciso adaptar o programa ou usar apenas os bytes do código gerado pelo programa. O segundo projeto, um cubo 8x8, é muito interessante e muito trabalhoso também. Nele o autor mostra passo a passo a construção tanto física como eletrônica do cubo de 512 leds, incluindo lista de componentes e a técnica usada para soldar simetricamente os leds.

Funcionameto

No cubo os leds são organizados em camadas horizontais, de modo que em uma mesma camada todos os catodos sejam unidos, e em colunas, formados pela união dos anodos três a três pelos anodos. Ligando o catodo comum de uma camada ao negativo e o anodo comum de uma coluna ao positivo o led que estiver simultaneamente na camada e na coluna escolhida acenderá.

Como cada coluna (anodos) de três leds é ligada a um pino do arduino (9 pinos) e cada camada (catodos) ligada, através de um transistor a um pino do arduino (3 pinos). Temos a seguinte dinâmica no cubo:

1- Coloca em nível alto o pino do arduino que liga ao GND, através do transistor correspondente, os catodos da camada inferior (camada 0);
2- Colocam-se em nível alto os pinos do arduino ligados aos leds da camada 0 que devem ser acesos;
3- Aguarda o tempo de exibição da camada;
4- Apaga todos os leds;
5- Repetem-se os passos anteriores para as camadas media (camada 1) e superior (camada 2).
Esse processo acontece em velocidade suficiente para parecer que leds de camadas distintas estão acesos simultaneamente.

Se chamarmos frame uma imagem "estática" exibida no cubo que seguida de outras imagens causa o efeito de movimento. O tempo de exibição desse frame é determinado pelo número de vezes que o ciclo citado acima se repete acendendo os mesmos leds nas mesmas camadas. Analisando o programa fica mais fácil entender.

Montagem

Soldar os leds é a parte que requer maior paciência para que fique o mais simétrico possível. Eu usei a técnica mostrada no segundo post mencionado acima. Ele traz muitas fotos que facilitam o entendimento.

O circuito é simples. Na matriz de contatos foram montados os 12 resistores e os 3 transistores BC548. O projeto usa 12 portas do arduino sendo 3 para polarizar os transistores responsáveis pelo GND de cada camada e 9 para as nove linhas verticais de leds.

O circuito completo pode ser visto ao lado. Os resistores ligados às bases dos transistores são de 330R e os demais são de 120R.

O Programa

O programa comentado pode ser visto abaixo.

 int camada[3] ={13,12,11};
int ledPin[9] = {1,2,3,5,6,7,8,9,10};// pinos de dados

byte aux[4] = {B00000000, B00000000, B00000000, B00000000};

                   // camada 0   camada 1  camada 2       
                                                     //012  camada
               //led  01234567   01234567   01234567   888 ultimo led de cada camada
byte efeito1[16] = { B10010010, B01000001, B00100100, B00100000,
                     B00000000, B11110111, B00000000, B01000000,
                     B00100100, B01000001, B10010010, B10000000,
                     B01001001, B01000001, B01001001, B00000000};
                     
byte efeito2[12] = { B11111111, B00000000, B00000000, B10000000,
                     B00000000, B11111111, B00000000, B01000000,
                     B00000000, B00000000, B11111111, B00100000};
                     
byte efeito3[8] = { B01011101, B01011101, B01011101, B00000000,
                    B10101010, B10101010, B10101010, B11100000};
                    
byte efeito4[16] = {B00011011, B00011011, B00011011, B00000000,
                    B11011000, B11011000, B11011000, B00000000,
                    B01101100, B01101100, B01101100, B00000000,
                    B00001101, B00001101, B00001101, B11100000};
                    
byte efeito5[32] = {B11100000, B11100000, B11100000, B00000000,
                    B11100000, B00011100, B00000011, B00100000,
                    B11111111, B00000000, B00000000, B10000000,
                    B00000011, B00011100, B11100000, B10000000,
                    B00000011, B00000011, B00000011, B11100000,
                    B00000011, B00011100, B11100000, B10000000,
                    B11111111, B00000000, B00000000, B10000000,
                    B11100000, B00011100, B00000011, B00100000};
                    
                    
byte efeito6[40] ={B00000011, B00010100, B11100000, B10000000,
                   B10010010, B01000001, B00100100, B00100000,
                   B00000000, B11110111, B00000000, B01000000,
                   B00100100, B01000001, B10010010, B10000000,
                   B01000001, B01000001, B01001001, B00000000,
                   B11100000, B00010100, B00000011, B00100000,
                   B10010010, B01000001, B00100100, B00100000,
                   B00000000, B11110111, B00000000, B01000000,
                   B00100100, B01000001, B10010010, B10000000,
                   B01000001, B01000001, B01001001, B00000000};
                   
byte efeito7[64] ={B10010000,B10010000,B10010000,B00000000,
                   B10001000,B10001000,B10001000,B00000000,
                   B11000000,B11000000,B11000000,B00000000,
                   B01001000,B01001000,B01001000,B00000000,
                   B01100000,B01100000,B01100000,B00000000,
                   B00101000,B00101000,B00101000,B00000000,
                   B00100100,B00100100,B00100100,B00000000,
                   B00001100,B00001100,B00001100,B00000000,
                   B00000100,B00000100,B00000100,B11100000,
                   B00001000,B00001000,B00001000,B11100000,
                   B00000001,B00000001,B00000001,B11100000,
                   B00001001,B00001001,B00001001,B00000000,
                   B00000011,B00000011,B00000011,B00000000,
                   B00001010,B00001010,B00001010,B00000000,
                   B00010010,B00010010,B00010010,B00000000,
                   B00011000,B00011000,B00011000,B00000000};
                    
int i =0;
int j=0;
int a =0;
int frame_time = 10;   // quantidade de iteracoes da cada frame
                                                           
void setup()                   
{
  int i;
  for(i=0;i<3;i++)
  pinMode(camada[i], OUTPUT);  // pinos como saida
  
  for(i=0;i<9;i++)
  pinMode(ledPin[i], OUTPUT);  // pinos como saida

}


void loop() // laço principal
{ 
 cubo(efeito1, 16, 10);  // vetor de efeito, qtd de bytes, numero de repeticoes de exibicao
 cubo(efeito2, 12, 10);
 cubo(efeito3, 8, 10);
 cubo(efeito4, 16, 10); 
 cubo(efeito5, 32, 10);
 cubo(efeito6, 40, 5);
 cubo(efeito7, 64, 10);
 
}  // fim do laço principal

   
 void cubo(byte *efeito, int tamanho, int repet)
 {
    while(repet > 0)
    {
         /* copia os bytes 4 a 4 para o vetor auxilias 
         na primeira iteração copia os 4 primeiros bytes do vetor efeito escolhido
         na segunda os 4 bytes seguintes
         repete até o final do vetor */
         
     for(int cnt1 =0; cnt1 < tamanho;)
      {   
       for(int cnt2 =0; cnt2 < 4; cnt2 ++)  // copia 4 bytes 
        {                                   
         aux[cnt2] = efeito[cnt1];          
         cnt1 ++;                           
        }                           
      mostra_frame();//acende os leds correspondentes aos 4 bytes         
     } 
     repet --;
   }                     
 }
 
                      
  void mostra_frame()
  {
    for(int cnt=0; cnt< frame_time; cnt++)
    {
       for(j=0; j< 3; j++) // seleciona a camada
       {
         digitalWrite(camada[j], HIGH); // polariza o transistor correspondente a camada j 
                                        // o que liga os catodos desta camadaao GND
         for(a=0; a< 8; a++) // verifica bit a bit o byte correspondente a camada ativa 
         {
           if(bitRead(aux[j] , a) == 1)  // se o bit for 1 
             digitalWrite( ledPin[7-a], HIGH); //acende o led correspondente
           else
             digitalWrite( ledPin[7-a], LOW); // se for 0 apaga
    
           if(bitRead(aux[3] , 7-j) == 1)  // verifica o bit do nono led que está no quarto byte
             digitalWrite( ledPin[8], HIGH);
           else
            digitalWrite( ledPin[8], LOW); 
        }
        delay(7);
        digitalWrite(camada[j], LOW);
      }
   }             
 }

Picaxe Triac

2011-04-25T19:29:00.000-07:00

Seguindo a linha de circuitos básicos. Esta postagem trata do controle de dispositivos alimentados por tensão da rede domestica 110v ou 220v através de um microcontrolador. Neste caso o picaxe 08M. Um triac é o componente principal da etapa de corrente alternada. Uma lâmpada é usada no exemplo mas nada impede o acionamento de outros dipositivos AC, como motores monofásicos, respeitando-se o limite de corrente no triac usado.

O circuito de força utilizado não foi concebido por mim, foi montado a partir destas informações publicadas no fórum do Arduino, onde é possível ver detalhe inclusive do layout da placa. Este circuito não controla a intensidade luminosa.

A idéia da montagem é bem simples Um potenciômetro, ligado a uma entrada analógica do picaxe, é usado para determinar o intervalo entre as piscadas de uma lâmpada incandescente comum. O desenho do circuito pode ser visto ao lado. Abaixo é mostrado o código fonte.

symbol pot_value = w1
symbol lamp_pin =  2


main: 'loop principal

READADC10 4, pot_value    ' le o valor do potenciometro ligado 
                  ' ao pino 2 e armazena em pot_value
    
high lamp_pin    'acende a lampada

pause pot_value  ' aguarda o tempo determinado pelo potenciometro

low lamp_pin     'apaga a lampada

pause pot_value  ' aguarda o tempo determinado pelo potenciometro

goto main        'fim do loop principal, retorna ao inicio

Arduino 8x8 leds

2011-04-06T16:21:00.000-07:00

Existe muita coisa na internet sobre matriz de leds 8x8. Inclusive com o arduino. Mesmo assim , partindo da idéia de que quanto mais, melhor, decidi criar esta postagem que descreve a ligação de uma destas matrizes ao arduino com o auxilio de um contador 4017.

Newton C. Braga neste artigo explica o funcionamento do contador 4017 incluindo exemplos de utilização, vale a pena.

Como o nome diz é uma matriz, naturalmente composta de linhas e colunas, cujos elementos são os leds. Numa matriz unicolor o "endereço" do led é dado por sua linha e coluna na bicolor e na RGB é preciso determinar além da linha e coluna a cor do led. Para acendermos um determinado led(linha, coluna), julgando que o anodo está ligado ao pino linha e o catodo ao coluna, devemos ligar a linha correspondente ao positivo e a coluna ao negativo da fonte.

Nesta montagem foi usada uma matriz bicolor, entretanto o código só usa a cor vermelha. Numa outra oportunidade postarei algo que use duas cores.

Funcionamento

O 4017 tem 10 saídas. Assim que ele é ligado b0 é colocado em nível alto (+5V) e a cada pulso de clock uma das saídas subsequentes é colocada em nível alto. O ciclo se repete depois que a décima saída é colocada em nível alto, ou que o reset seja acionado, reiniciando a contagem. Aqui o 4017 é responsável pelo +5 de cada linha de led. A cada pulso de clock enviado pelo arduino ele alimenta os anodos dos diodos de uma das linhas da matriz, começando de cima.

As colunas são ligadas diretamente ao arduino que deve colocar a saída correspondente em nível baixo (0V) para acender o led cuja linha esteja sendo alimentada, com 5V, pelo 4017, conforme figura acima.
Cada caractere é armazenado em um vetor de oito bytes onde cada byte corresponde a uma linha da matriz, sempre de cima para baixo. Neste vetor '0' representa led apagado e '1' aceso.

Por exemplo, para a letra A:

B0 0 0 1 1 1 1 1 0 0

B1 0 1 1 1 1 1 1 1 0

B2 1 1 0 0 0 0 0 1 1

B3 1 1 0 0 0 0 0 1 1

B4 1 1 1 1 1 1 1 1 1

B5 1 1 0 0 0 0 0 1 1

B6 1 1 0 0 0 0 0 1 1

B7 1 1 0 0 0 0 0 1 1

Teremos o vertor: A[8] = {B00111100, B01111110, B110000011, B110000011, B111111111, B110000011, B110000011, B110000011}

O programa

A dinâmica do programa é a seguinte:

1. O texto é armazenado em um vetor;

2. O programa pega caractere por caractere compara com os caracteres disponíveis e armazena o vetor correspondente em uma vetor auxiliar;

3. Cada byte, bit a bit, é armazenado em uma linha da matriz "aux" ;

4. A matriz aux é passada para a função que imprime no display;

5. Para dar a idéia de deslocamento a primeira coluna da matriz aux copia a segunda, a segunda copia a terceira isso até que oitava coluna seja copiada pela sétima e receba a primeira coluna do próximo caractere ou colunas em branco enviadas pela função "apaga_coluna(n° de colunas)". Existe, também a possibilidade de mostrar, sem deslocamento, o caractere no display atravéz do parametro modo da função escreve.

O código fonte pode ser visto abaixo.

#include <string.h>

              //  0 1 2 3 4 5 6 7
 int aux[8][8]= {0,0,0,0,0,0,0,0, //0     //poderia ter usado dois laços um para colunas outro para linhas pra fazer o mesmo
     /*  k  m */ 0,0,0,0,0,0,0,0, //1     //mas assim parece mais didatico
                 0,0,0,0,0,0,0,0,         // k linha    m columa
                 0,0,0,0,0,0,0,0,
                 0,0,0,0,0,0,0,0,
                 0,0,0,0,0,0,0,0,
                 0,0,0,0,0,0,0,0,
                 0,0,0,0,0,0,0,0};

int aux2[8][8];    // cada byte corresponde a uma linha da letra de cima para baixo        
             // linha 1          2          3           4          5          6          7          8
     byte A[8] = {B00111100, B01111110, B11000011, B11000011, B11111111, B11111111, B11000011, B11000011};            
     byte B[8] = {B11111110, B11111111, B11000111, B11111110, B11111110, B11000111, B11111111, B11111110};               
     byte C[8] = {B11111111, B11111111, B11000000, B11000000, B11000000, B11000000, B11111111, B11111111};               
     byte D[8] = {B11111100, B11111110, B11000111, B11000011, B11000011, B11000111, B11111110, B11111100};      
     byte E[8] = {B11111111, B11111111, B11000000, B11111100, B11111100, B11000000, B11111111, B11111111};                
     byte F[8] = {B11111111, B11111111, B11000000, B11111100, B11111100, B11000000, B11000000, B11000000};
     byte G[8] = {B11111111, B11111111, B11000001, B11000000, B11001111, B11000011, B11111111, B11111111};
     byte H[8] = {B11000011, B11000011, B11000011, B11111011, B11111111, B11000011, B11000011, B11000011}; 
     byte I[8] = {B11111111, B11111111, B00011000, B00011000, B00011000, B00011000, B11111111, B11111111};
     byte J[8] = {B01111111, B01111111, B00001100, B00001100, B11001100, B11001100, B11111100, B01111000};                                    
     byte K[8] = {B11000011, B11000111, B11001110, B11111100, B11111100, B11001100, B11000111, B11000011};         
     byte L[8] = {B11000000, B11000000, B11000000, B11000000, B11000000, B11000000, B11111111, B11111111};
     byte M[8] = {B11000011, B11100111, B11111111, B11011011, B11011011, B11000011, B11000011, B11000011};  
     byte N[8] = {B11000011, B11100011, B11110011, B11111011, B11011111, B11001111, B11000111, B11000011};  
     byte O[8] = {B01111110, B11111111, B11000011, B11000011, B11000011, B11000011, B11111111, B01111110};
     byte P[8] = {B11111110, B11111111, B11000011, B11111111, B11111110, B11000000, B11000000, B11000000};           
     byte Q[8] = {B01111110, B11111111, B11000011, B11000011, B11001011, B11000111, B11111110, B01111101};      
     byte R[8] = {B11111110, B11111111, B11000011, B11000010, B11111100, B11111110, B11000111, B11000111};     
     byte S[8] = {B11111111, B11111111, B11000000, B11111111, B11111111, B00000011, B11111111, B11111111};
     byte T[8] = {B11111111, B11111111, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000};
     byte U[8] = {B11000011, B11000011, B11000011, B11000011, B11000011, B11000011, B11111111, B01111110};
     byte V[8] = {B11000011, B11000011, B11000011, B11000011, B11000011, B01100110, B00111100, B00011000};
     byte X[8] = {B11000011, B11100111, B01100110, B00011000, B00011000, B01100110, B11100111, B11000011};
byte ponto[8] =  {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00011000, B00011000};
byte coracao[8]= {B01100110, B11111111, B11111111, B11111111, B11111111, B01111110, B00111100, B00011000}; 
byte espaco[8] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}; 


int cont = 0;

int ckPin = 13;                // clock para o contador
int displayPin[8] = {12,11,10,9,8,7,6,5};// pinos de dados
int rstPin = 3;    // reset contador

void setup()                   
{
  int i;
  
  pinMode(ckPin, OUTPUT);      
  pinMode(rstPin, OUTPUT);
  
  for(i=0;i<8;i++)
  pinMode(displayPin[i], OUTPUT);  // pinos com saida

}
char *frase ={"TECNOMELQUE.BLOGSPOT.COM  "};  // texto a ser mostrado  {"AABBCC"};
int t =0;
void loop()                     //inicio programa principal     n
{
 t =0;
 while(t < strlen(frase))
  {                            // envia letra por letra da frase para funcao escreve
  escreve(frase[t], 1, 100);  // caracte, modo 0 apenas mostra 1 desloca, tempo 
  
  apaga_coluna(2); // espaco entre letras passa quantidade de colunas
  t++;
  }
  apaga_coluna(8);
  escreve('~',0,1000);
  delay(500);
  escreve('~',0,1000);
  delay(500);
  escreve(' ',0,100);

  
 
}  //fim da funcao principal

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

  void escreve(char letra, int modo, int tmp){
  int k;
  byte *Lt;
  
  switch(letra)   // compara a letra e armazena o vetor correspondente em Lt 
  {
  case 'A':
  Lt=A;
  break;
  
  case 'B':
  Lt=B;
  break;
  
 case 'C':
 Lt=C;
 break;

  case 'D':
 Lt=D;
  break;
  
  case 'E':
Lt=E;
  break;
  
  case 'F':
Lt=F;
  break;
  
  case 'G':
Lt=G;
  break;
  
  case 'H':
Lt=H;
  break;
  
  case 'I':
 Lt=I;
  break;
  
  case 'J':
Lt=J;
  break;
  
  case 'K':
Lt=K;
  break;

  case 'L':
 Lt=L;
  break;
  
  case 'M':
  Lt=M;
  break;
  
  case 'N':
  Lt=N;
  break;
 
  case 'O':
  Lt=O;
  break;
  
  case 'P':
  Lt=P;
  break;
  
  case 'Q':
Lt=Q;
  break;


  case 'R':
Lt=R;
  break;

  case 'S':
Lt=S;
  break;
  
  case 'T':
Lt=T;
  break;
  
  case 'U':
Lt=U;
  break;
  
  case 'V':
Lt=V;
  break;
  
 case 'X':
Lt=X;
  break;

  case '.':
  Lt=ponto;
  break;
  
  case '~':
 Lt=coracao;
  break;
  

 case ' ':
 Lt=espaco;
  break;

 }
  

 //copia o caracter para aux
 // bit por bit é armazenado na matriz aux
   for(int i=0; i<8;i++)
   {
     for(int j=0; j<8;j++)
     {
      if(modo == 0)
      aux[i][j] = bitRead(Lt[i], 7-j); 
      else
       aux2[i][j] = bitRead(Lt[i], 7-j); 
     }
   }

  if ( modo == 0)  // mostra ccaracter
 {
    imprime(tmp);
  }
  else if( modo == 1)  // modo 1 desloca caracter anterior
  {
    
  cont = 0;
   
  for (int passo =0; passo <8; passo++)
  {
    
  for(k=0; k<8; k++)  // linhas
  {
    
  for(int m=0; m < 7;  m++)   
  {
    
   aux[k][m] = aux[k][m+1];

  }
   aux[k][7] = aux2[k][cont];   // ultima coluna de aux recebe a primeira coluna de  E
  }
  
  cont ++; 

  imprime(tmp);  // mostra no display

  } //fim da contagem de passos
} // fim de escreve letra

  }
  
 
   

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

void apaga_coluna(int qtd)
{
 int k;
  
for (int passo =0; passo <qtd; passo++)
  {
    
  for(k=0; k<8; k++)  // linhas
  {
    
  for(int m=0; m < 7;  m++)   
  {
    
   aux[k][m] = aux[k][m+1];

  }
   aux[k][7] = 0;   // ultima coluna de aux recebe a primeira coluna de  E
  }
  
  cont ++;
 
  imprime(100);  // mostra no display

 } //fim da contagem de passos

} //fim apaga coluna

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

 void imprime(int tmp)
 {
 // int tmp = 100;

  for(int a=0; a < tmp; a++)   // tmp representa a quantidades de vezes que cada caracter é exibido
  {     
  digitalWrite(rstPin, LOW); // prepara para reset do contador
  
    for(int i =0; i<8; i++) // linhas
    {
     digitalWrite(ckPin, LOW); // como a mudança ocorre na descida do clock esta linha so faz sentido no segund ciclo
  
   for(int j=0;j<8;j++)   // colunas
  {
      if(aux[i][j] == 1) 
      {
       digitalWrite(displayPin[j], LOW);
      }
     else
     {
     digitalWrite(displayPin[j], HIGH);
     }
  }
    
  delay (0.5); // entre linhas
  
   for(int i=0;i<8;i++)                    // apaga a linha
   digitalWrite(displayPin[i], HIGH);
 
  digitalWrite(ckPin, HIGH); 
   
 }
 
  digitalWrite(rstPin, HIGH);  // reset do contador
 
 }  
 }

Picaxe 08M - Display de sete segmentos

2011-03-10T20:51:00.000-08:00

Se preferir assista no youtube.

O display de sete segmentos é muito usado em circuito com microcntroladores. Esta postagem mostra como ligá-lo ao picaxe 08M com o auxilio do shift register 74hc595, já que este picaxe possui apenas quatro pinos que podem ser usados como saída.

A postagem "Arduino dimmer com display de sete segmentos" traz alguns detalhes sobre o display de sete segmentos que serão úteis nesta montagem. Os dígitos serão formados a partir da mesma tabela, acrescentando-se um zero à direita do bit menos significativo de cada número da tabela para completar o byte.

O 08M envia cada byte, bit a bit, para o 7495 que tem suas oito saídas ligadas ao display. A saída Q7 foi ligada ao pino correspondente ao ponto. Um bom tutorial sobre o shift register pode ser encontrado no site do arduino. Basicamente para usá-lo é preciso três sinais: um clock para o shift, um clock para o latch e o terceiro deve conter o bit de dado.

O Programa

Para formar um número no display são enviados oito bits através do pino "out0" do picaxe, denominado aqui como dataPin. Por exemplo, para formar o número zero, considerando 1 para segmento aceso e 0 para apagado, temos que enviar o byte "11111100" que corresponde, em decimal, a 252. O programa segue a sequência abaixo:

1 - Armazena o byte em "b0" que começa no bit 0 e termina no bit 7;
2 - Coloca o clock do latch em nível baixo;
3 - Coloca o clock do shift em nível baixo. Preparando-o para a passagem do bit que acontece na mudança do clock do nível baixo para o alto (0 para 1);
4 - Verifica o estado do bit0, que neste caso é 0 colocando o dataPin em nível baixo;
5 - Coloca o clock do shift em nível alto. O bit0 vai para a saída do primeiro registrador do shift que também é a entrada do segundo;
6 - Os paços 3 , 4 e 5 se repetem para os outros sete bits. Cada vez que um bit é adicionado os outros são "empurrados" para o registrador seguinte;
7 - Após completar o envio dos oito bits coloca o clock do latch em nível alto fazendo com que todos os bits apareçam na saída do CI, mostrando assim o dígito no display.

symbol dataPin = 0  ' pino do dados seriais

symbol latchPin = 2  ' clock do latch apos ter todos os dado vai a nivel alto para mostrar na saida

symbol shiftPin = 1  ' clock do registrador de deslocamento

symbol cnt1 = b1

symbol dados = b0


main: 'laco principal


   for b4=0 to 9
   
'lookup armazena o numero que esta na posicao b4 na variavel "dados"

             '0   1  2   3   4   5   6   7   8   9
   lookup b4,(252,96,218,242,102,182,190,224,254,246),dados
   
   low latchPin 'clock do latch em nivel baixo

      for cnt1 =0 to 7 
    
        low shiftPin   'clk do shift em nivel baixo 
        
    
  ' a cada passagem verifica se o bit correspondente
  ' é zero ou um e coloca a saida em nivel alto ou baixo respectivamente  
  
      select cnt1
    
    case 0
    {
     if bit0 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    case 1
    {
     if bit1 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    
    case 2
    {
     if bit2 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    
    case 3
    {
     if bit3 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
   
    case 4
    {
     if bit4 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    case 5
    {
     if bit5 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    case 6
    {
     if bit6 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    case 7
    {
     if bit7 = 1 then
         
        high dataPin
     else
       low dataPin
     endif 
    }
    
    endselect
        
      
       high shiftPin 'clk shift pin em nivel alto envia o bit para o proximo registrador
    
      next cnt1

   high latchPin 'clock do latch apos ter todos os dado (8 bits)
                'vai a nivel alto para mostrar na saida do 7495
                
    pause 945   'entre numeros
    
    next b4     ' fim do laco for

    
goto main ' fim do laco pricipal

Picaxe PWM

2011-03-08T20:10:00.000-08:00

Se preferir assista no youtube.

Alguns circuitos são básicos para muitas montagens mecatrônicas, controlar a velocidade de rotação de um motor de corrente continua por PWM é um deles. O circuito mostrado aqui usa um potenciômetro ligado a uma entrada analógica de um Picaxe 08M (conversor AD de 10 bits), como usado na montagem com servomotor, para controlar a rotação de um motor DC.

O sinal PWM gerado no picaxe é aplicado ao gate do MOSFET IRF540, através do acoplador óptico 4n25. O diagrama completo do circuito é mostrado ao lado. Um resistor de 330R é usado para limitar a corrente no led do 4n25. O resistor ligado entre o gate do mosfet e o GND é de 10k. O potenciômetro pode ser de qualquer valor.

Para testar o circuito foi usada uma pequena furadeira que em 12V tem corrente, à vazio, menor que 1A, mas o mosfet usado pode suportar correntes superiores a 10A respeitando-se, é claro, as recomendações do datashet para limite de corrente que além das características eletrônicas do componente é influenciado pelo tipo de dissipador adotado.

O programa

No código, mostrado abaixo, o valor do potenciômetro é lido 0 - 1023 e aplicado ao pino 4 através da função "pwmout" que precisa de três parâmetros: pino (pino de saída do sinal), período (período do sinal, 0 a 255) e ciclo de trabalho (grosseiramente falando é o valor do PWM, 0 a 1023).

symbol pot_value = w1

symbol motor_pin =  2

main: 'loop principal

READADC10 4, pot_value ' le o valor do potenciometro 

pwmout motor_pin,255,pot_value ' envia o valor para o pino 2

goto main 'fim do loop principal

Wii Nunchuk, arduino e labirinto de madeira

2011-02-26T15:12:00.000-08:00

Visitando o site instructables que, diga-se de passagem, é um site muito bom, encontrei o projeto Servo Controlled Labyrinth by nivini . Decidi então, tendo como referência a ideia do autor, montar o jogo usando o arduino e o nunchunk para controlar o tabuleiro. Como não tinha o jogo tradicional montei meu próprio tabuleiro usando duas caixas em mdf e quatro pedaços de compensado 4mm além de outras pequenas peças adaptadas de matérias disponíveis em casa, o que rendeu um pouco mais de trabalho, mas nada exagerado. Se você já tiver o labirinto pode montar toda a parte física como no projeto original, o que torna as coisas mais fáceis.

O labirinto

Para a confecção do labirinto usei uma caixa em MDF de 25cm x 25cm e a tampa de outra caixa em MDF 20cm x 20cm, onde foi montado o labirinto propriamente dito com pedaços das peças de um pega varetas "gigante" (5mm de diâmetro), um brinquedo abandonado por minha filha de três anos. Quatro pedaços de compensado serviram para fazer o quadro intermediário. Neste quadro foi fixado o primeiro servo que tem seu eixo preso no centro de uma das laterais da tampa 20x20 e é responsável pelo movimento no eixo Y. O segundo servo, que é responsável pelo movimento no eixo X, é fixado à caixa maior e tem seu eixo preso em uma das laterais do quadro intermediário de modo a ficar perpendicular ao primeiro servo.

O código

O código, que pode ser visto abaixo, foi adaptado do código encontrado neste site: http://www.windmeadow.com/node/42 .

Eu substitui a parte do código que imprime os valores na tela pelo controle dos servos. Pra melhora a estabilidade o código faz uma media dos últimos 20 valores lidos, ajusta a escala e aplica os resultados aos servos.

 /*  
  * NunchuckPrint  
  *  
  * 2007 Tod E. Kurt, http://todbot.com/blog/  
 BRANCO------ GND  
 AZUL-------- SCL pino analogico 5  
 VERMELHO---- +3.3V  
 VERDE------- SDA pino analogico 4  
  */  
 #include <Wire.h>  
 #include <Servo.h>   
 Servo servo_y; // create servo object to control a servo   
 Servo servo_x; // create servo object to control a servo   
 #define m_movel 20 // quantidade de leituras para media  
 int media_leit_y =0;   
 int media_y_aux =0;  
 int aux_soma_y = 0;  
 int aux_m_y[m_movel];  
 int media_leit_x =0;   
 int media_x_aux =0;  
 int aux_soma_x = 0;  
 int aux_m_x[m_movel];  
 void setup()  
 {  
  servo_x.attach(9); // attaches the servo on pin 9 to the servo object   
  servo_y.attach(10);  
  Serial.begin(19200);  
  nunchuck_setpowerpins(); // use analog pins 2&3 as fake gnd & pwr  
  nunchuck_init(); // send the initilization handshake  
  Serial.print ("Finished setup\n");  
  for(int i=0; i < m_movel; i++)  
  {  
  aux_m_y[i] =0;  
  aux_m_x[i] =0;  
  }  
 }  
 void loop()  
 {  
  nunchuck_get_data(); // lê dados   
  aciona_servos();   // envia-os para os servos  
  delay(5);  
 }  
 //  
 // Nunchuck functions  
 //  
 static uint8_t nunchuck_buf[6];  // array to store nunchuck data,  
 // Uses port C (analog in) pins as power & ground for Nunchuck  
 static void nunchuck_setpowerpins()  
 {  
 #define pwrpin PORTC3  
 #define gndpin PORTC2  
   DDRC |= _BV(pwrpin) | _BV(gndpin);  
   PORTC &=~ _BV(gndpin);  
   PORTC |= _BV(pwrpin);  
   delay(100); // wait for things to stabilize      
 }  
 // initialize the I2C system, join the I2C bus,  
 // and tell the nunchuck we're talking to it  
 void nunchuck_init()  
 {   
  Wire.begin();             // join i2c bus as master  
  Wire.beginTransmission(0x52);     // transmit to device 0x52  
  Wire.send(0x40);          // sends memory address  
  Wire.send(0x00);          // sends sent a zero.   
  Wire.endTransmission();     // stop transmitting  
 }  
 // Send a request for data to the nunchuck  
 // was "send_zero()"  
 void nunchuck_send_request()  
 {  
  Wire.beginTransmission(0x52);     // transmit to device 0x52  
  Wire.send(0x00);          // sends one byte  
  Wire.endTransmission();     // stop transmitting  
 }  
 // Receive data back from the nunchuck,   
 int nunchuck_get_data()  
 {  
   int cnt=0;  
   Wire.requestFrom (0x52, 6);     // request data from nunchuck  
   while (Wire.available ()) {  
    // receive byte as an integer  
    nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());  
    cnt++;  
   }  
   nunchuck_send_request(); // send request for next data payload  
   // If we recieved the 6 bytes, then go print them  
   if (cnt >= 5) {  
    return 1;  // success  
   }  
   return 0; //failure  
 }  
 void aciona_servos()  
 {   
  for(int cnt = m_movel-1; cnt > 0; cnt --)  
  {  
  aux_m_y[cnt] = aux_m_y[cnt-1];  
  aux_soma_y = aux_soma_y + aux_m_y[cnt];  
  aux_m_x[cnt] = aux_m_x[cnt-1];  
  aux_soma_x = aux_soma_x + aux_m_x[cnt];  
  }  
  int joy_x_axis = nunchuck_buf[0];  
  int joy_y_axis = nunchuck_buf[1];  
  int z_button = nunchuck_buf[5] & 1;  
  int c_button = nunchuck_buf[5] >> 1 & 1;  
  int accel_x_axis = (nunchuck_buf[2] << 2) + ((nunchuck_buf[5] >> 2) & 0x03);  
  int accel_y_axis = (nunchuck_buf[3] << 2) + ((nunchuck_buf[5] >> 4) & 0x03);  
  int accel_z_axis = (nunchuck_buf[4] << 2) + ((nunchuck_buf[5] >> 6) & 0x03);  
  // media eixo Y ////  
  aux_m_y[0] = accel_y_axis;  
  aux_soma_y = aux_soma_y + aux_m_y[0];   
  media_y_aux = aux_soma_y /m_movel;  
  aux_soma_y = 0;  
  media_leit_y = constrain(media_y_aux, 375, 595);  
  media_leit_y = map(media_leit_y, 375, 595, 110, 70);  
  // media eixo X ////  
  aux_m_x[0] = accel_x_axis;  
  aux_soma_x = aux_soma_x + aux_m_x[0];   
  media_x_aux = aux_soma_x /m_movel;  
  aux_soma_x = 0;  
  media_leit_x = constrain(media_x_aux, 375, 595);  
  media_leit_x = map(media_leit_x, 375, 595, 70, 110);  
  servo_y.write(media_leit_y);       // tell servo to go to position in variable 'pos'   
  servo_x.write(media_leit_x);   
   }  
 char nunchuk_decode_byte (char x)  
 {  
  x = (x ^ 0x17) + 0x17;  
  return x;  
 }

Picaxe, Servo e potenciômetro

2011-02-14T15:06:00.000-08:00

Na ultima postagem sobre o Picaxe comentei que pretendia compra um para testá-lo e aprender sobre ele. Pois bem, comprei um 08M, o mais simples de todos com exceção do picaxe 08.

A montagem que descrevo aqui é bastante simples, mas não deixa de ser útil para aqueles, que como eu, estão começando a programar o picaxe. A idéia é receber o sinal 0 a 5v de um potenciômetro através de uma entrada analógica que em 10 bits retorna um valor de 0 a 1023 (2^10 = 1024 valores possíveis), mudar esse valor para uma escala de 75 a 225 e usando a função "servopos pino, valor”, aplicá-lo ao servo ligado ao pino 4 do picaxe através de um resistor de 330R, recomendado pelo manual.

O diagrama é mostrado no vídeo. Dependendo da marca do servo utilizado existe uma variação das cores dos fios de conexão. O positivo normalmente é vermelho o negativo preto ou marrom e o fio de sinal amarelo ou branco. Pra garantir é melhor pesquisar pelo modelo do servo. O potenciômetro pode ser de qualquer valor.

Um cuidado especial deve ser tomado com a alimentação do picaxe. Inverter positivo e negativo significa queimá-lo. Não é aconselhável, também, usar tensões acima de 5v.

O código:

symbol pot_value = w1
symbol servo_value = w2

init: servo 4,75 ; inicializa o servo

main: 'loop principal

READADC10 2, pot_value    ' le o valor do potenciometro ligado ao pino 2 e armazena em pot_value

pot_value = pot_value * 5 / 34  ' mudando da escala lida no pot 0 - 1023 para 75 a 225 aprox

servo_value = pot_value + 75 
   
servopos 4,servo_value 'manda o valor para o servo no saida 4 do picaxe (pino 3 do CI)

goto main 'fim do loop principal