Tag Archives: Meios de Entrada

Display TFT de 3.2″ com touchscreen

Módulo TFT
Shield adaptador
Conjunto montado

Aparência do módulo ligado, rodando o demo. Na foto abaixo eu mostro um modelo azul, mas o modelo ofertado neste anúncio é vermelho.

O kit vermelho está no fim. Novos compradores deverão receber o kit azul. Funcionalmente é a mesma coisa.

Shield_Adaptador_TFT_IMG_1182_640_automalabs.com.br

É importante ter em mente que o display, a touchscreen e o leitor de cartões são independentes. Você pode testar cada um separadamente.

 

Bibliotecas necessárias:

UTFT

UTouch

Com estas bibliotecas instaladas, seus exemplos funcionam com este kit sem maiores modificações, exceto talvez a calibração do touchscreen. Mas atente para o fato de que os demos vem ajustados para o Arduino UNO e se você estiver usando um Mega precisará comentar uma linha e “descomentar” outra. Cada sketch de demo mostra qual é.

 

Coordenadas da touchscreen invertidas
Se rodando o exemplo Button Test, ao apertar um botão for acionado outro na outra extremidade, é porque o digitalizador apresenta coordenada X invertida

Troque (no sketch exemplo):

x=myTouch.getX();

por:

x=320-myTouch.getX();

Se a calibração da touchscreen não funcionar, leia as instruções (desatualizadas) a seguir, pois eu explico como resolver isso.

O que se segue está desatualizado e vou manter aqui porque pode ser útil caso você precise adaptar um programa antigo

Bibliotecas necessárias:

UTFT
http://www.henningkarlsen.com/electronics/library.php?id=51

ITDB02_Touch
http://www.henningkarlsen.com/electronics/library.php?id=55

Nota: ITDB02_Touch mudou recentemente para outra biblioteca. Talvez você tenha que fazer adaptações. Por isso estou mandando em anexo as versões que eu uso.


Para testar o display
(sem o touchscreen)

Abra o exemplo UTFT->Arduino->UTFT_Demo_320x240

Substitua essas quatro linhas (inclui comentários):
// Uncomment the next line for Arduino 2009/Uno
UTFT myGLCD(ITDB32S,19,18,17,16);   // Remember to change the model parameter to suit your display module!
// Uncomment the next line for Arduino Mega
//UTFT myGLCD(ITDB32S,38,39,40,41);   // Remember to change the model parameter to suit your display module!
por:
UTFT myGLCD(ITDB32S,38,39,40,41);
Execute o teste
Touchscreen
O sketch exemplo de calibração da biblioteca não funciona.
Eu já testei com várias telas e nunca funcionou. É preciso editar ITDB02_Touch.cpp para fazer a calibração.Você precisa editar o arquivo:
libraries\ITDB02_Touch\ITDB02_Touch.cpp
Substitua os quatro primeiros parâmetros por isto:
#define PixSizeX    -16
#define PixOffsX    206
#define PixSizeY    11
#define PixOffsY    380
Feche o IDE se estiver aberto e abra de novo, para validar a modificação.
Abra o exemplo ITDB02_Touch->ITDB02_Touch_ButtonTest
Substitua#include <ITDB02_Graph.h>

por

#include <UTFT.h>

Substitua:

// Uncomment the next two lines for the ITDB02 Shield
ITDB02        myGLCD(19,18,17,16);
ITDB02_Touch  myTouch(15,10,14,9,8);

// Uncomment the next two lines for the ITDB02 Mega Shield
//ITDB02        myGLCD(38,39,40,41);   // Remember to add ASPECT_16x9 if you are using an ITDB02-3.2WC!
//ITDB02_Touch  myTouch(6,5,4,3,2);

por:
UTFT myGLCD(ITDB32S,38,39,40,41);  // Remember to add ASPECT_16x9 if you are using an ITDB02-3.2WC!
ITDB02_Touch  myTouch(6,5,4,3,2);

Compile e teste.

Bibliotecas e arquivos de suporte:
UTFT
UTFT
UTFT.rar
637.8 KiB
310 Downloads
Detalhes...
ITDB02 Touch
ITDB02 Touch
ITDB02_Touch.rar
40.8 KiB
309 Downloads
Detalhes...
ITDB02 Touch.cpp
ITDB02 Touch.cpp
ITDB02_Touch.cpp
5.1 KiB
2010 Downloads
Detalhes...
Postado em Produtos | Tags: , , , | Deixe um comentário

Módulo RFID 125KHz com saída UART – RDM6300

Com este módulo você poderá ler tags RFID de 125khz no arduino, ou em qualquer computador, desde que use também um adaptador serial TTL-USB.

Não deixe a quantidade de pinos intimidar você. A conexão mínima só requer três fios:

  • +5V
  • GND
  • TX (para o Arduino, PC, etc)

Nota: O módulo tem um pino RX, mas seu propósito não é esclarecido.

Diagrama de conexão, com o módulo visto por baixo:

O módulo tem um microcontrolador próprio, que se encarrega de todo o trabalho de decodificação RFID, já entregando na saída o número da tag (chaveiro, cartão, etc).

A saída é serial UART TTL padrão (9600bps, 8,N,1). Para usar com qualquer Arduino, nenhum hardware extra é necessário, porque basta ligar o TX do módulo ao RX do Arduino. Caso você use um Arduino que só tem uma porta serial como o Duemilanove e o Uno, pode usar a biblioteca NewsoftSerial para criar uma porta “virtual” em qualquer outro pino e assim liberar a porta serial padrão para outras tarefas.

Para usar com um computador, é preciso usar um conversor USB-serial TTL ou RS232 – TTL.

Alcance da antena: no máximo 3cm.

Proteção contra inversão de polaridade por diodo em série.

O número da tag é transmitido em um formato codificado que é explicado no datasheet em anexo, que é o único oferecido pelo fabricante. Eu o acho um bocado confuso, por isso escrevi um programa em Delphi, também em anexo, que ajudará você a entender como o número transmitido se relaciona com o real, escrito na tag. Porém em boa parte das aplicações o número escrito na tag é irrelevante, pois o que importa é que o usuário apresente uma tag que está registrada no sistema. O número impresso só se torna importante quando você quer testar a tag ou correlacionar o uso das tags com um usuário específico.

Exemplo da tela do programa:

Para testar com um arduino você pode usar o ótimo exemplo de Mario Boehmer, que reproduzo abaixo ligeiramente traduzido (ligue o TX ao pino D6 do arduino):

Atenção: Requer a biblioteca NewsoftSerial e para funcionar no Arduino 1.x requer modificações (testei no 0.22).


//http://marioboehmer.blogspot.com.br/2011/01/rfid-with-arduino.html

#include "NewSoftSerial.h"
#define stx 2
#define etx 3

NewSoftSerial mySerial(6, 7);
int counter;
byte data[14];
byte hexBlock1,hexBlock2,hexBlock3,hexBlock4,hexBlock5;
byte hexCalculatedChecksum,hexChecksum;

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

void loop() {
if (mySerial.available() > 0) {
data[counter] = mySerial.read();
counter++;
if(counter > 13) {
//we read the whole message, so reset counter
counter = 0;
//check if start of text and end of text is correct
if(data[0] == stx && data[13] == etx) {
Serial.println("Caracteres STX e ETX corretamente recebidos");
Serial.print("ID: ");
//show ID
for(int x = 1; x < 11; x++) {
Serial.print(data[x], BYTE);
}
Serial.println("");
Serial.print("Checksum: ");
//show checksum
Serial.print(data[11], BYTE);
Serial.println(data[12], BYTE);

//Hex ID blocks. Two transmitted Bytes form one Hex ID block.
//Hex ID blocks:      6   2  |  E   3  |  0   8  |  6   C  |  E   D
//Transmitted Bytes: 36H 32H | 45H 33H | 30H 38H | 36H 43H | 45H 44H
hexBlock1 = AsciiCharToNum(data[1])*16 + AsciiCharToNum(data[2]);
hexBlock2 = AsciiCharToNum(data[3])*16 + AsciiCharToNum(data[4]);
hexBlock3 = AsciiCharToNum(data[5])*16 + AsciiCharToNum(data[6]);
hexBlock4 = AsciiCharToNum(data[7])*16 + AsciiCharToNum(data[8]);
hexBlock5 = AsciiCharToNum(data[9])*16 + AsciiCharToNum(data[10]);

//Transmitted checksum.
hexChecksum = AsciiCharToNum(data[11])*16 + AsciiCharToNum(data[12]);

//XOR algorithm to calculate checksum of ID blocks.
hexCalculatedChecksum = hexBlock1 ^ hexBlock2 ^ hexBlock3 ^ hexBlock4 ^ hexBlock5;
if ( hexCalculatedChecksum == hexChecksum )
{
Serial.println("Checksum calculado confere com checksum transmitido.");
}
else {
Serial.println("Checksum calculado NAO confere com checksum transmitido. Dados corrompidos!");
}
}
}
}
}

uint8_t AsciiCharToNum(byte data) {
//First substract 48 to convert the char representation
//of a number to an actual number.
data -= '0';
//If it is greater than 9, we have a Hex character A-F.
//Substract 7 to get the numeral representation.
if (data > 9)
data -= 7;
return data;
}

Postado em Produtos | Tags: | Deixe um comentário

Como conectar um teclado ou mouse PS/2 ao arduino

Sim, você pode. E é mais fácil do que parece, pois você pode conectar os fios do teclado diretamente ao arduino. Porém se quiser poder testar qualquer teclado/mouse sem danificar os cabos, precisa de um adaptador como este:

  • Vermelho: +5V;
  • Preto: GND;
  • Amarelo: Clock – Precisa ser ligado ao pino 3 do arduino, porque funciona como interrupção;
  • Branco: DATA

OBS.: Eu não consigo me ver usando um mouse no arduino, mas um teclado PS/2 é barato, fácil de conseguir e muito conveniente como forma de interagir com o arduino.

Biblioteca, conexões e exemplos

Postado em Produtos | Tags: | 2 Comments

Wii nunchuck no arduino

Este produto está disponível nos modelos com fio e sem fio. Ambos acompanham adaptador wiichuck.

O Wii nunchuck é um dispositivo I2C que responde no endereço 0x52 e possui um joystick, dois botões e um acelerômetro cujas posições você pode “ler” usando rotinas adequadas no arduino.  Apenas quatro fios são necessários: VCC, GND, SCL e SDA.

Teoricamente ele é um dispositivo de 3V, mas a prática mostrou que você pode alimentá-lo com 5V no arduino sem problemas.

Existem dois tipos de nunchuck no mercado: o original (ou “OEM”) e o genérico. Embora os dois funcionem no Wii aparentemente sem diferença, quando tentamos usar no Arduino três diferenças são percebidas:

  • O genérico tem um acelerômetro menos preciso;
  • A calibração do joystick varia bastante entre genéricos;
  • O genérico pode ou não suportar criptografia na comunicação I2C.

A terceira diferença é a mais importante, pois o nunchuck que não suporta criptografia precisa ser usado de maneira diferente. O Wii se encarrega de fazer isso de forma transparente, mas uma grande quantidade de exemplos de uso do nunchuck no arduino que você encontra na internet prevê o uso de um original e por isso pode não funcionar com muitos genéricos. É preciso  procurar por exemplos que tenham sido feitos para genéricos.

Este sketch de teste funciona com originais e genéricos, usando ou não o adaptador Wiichuck:

/*
* NunchuckPrint
*
* 2007 Tod E. Kurt, http://todbot.com/blog/
*
* The Wii Nunchuck reading code is taken from Windmeadow Labs
*   http://www.windmeadow.com/node/42
*/

#include <Wire.h>

void setup()
{
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");
}

void loop()
{
nunchuck_get_data();
nunchuck_print_data();
delay(100);
}

//
// 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

//Só funciona com o original
//  Wire.send(0x40);        // sends memory address
//  Wire.send(0x00);        // sends sent a zero.

//Funciona com a versão xing-ling
#if (ARDUINO >= 100)
Wire.write(0xF0);
Wire.write(0x55);
#else
Wire.send(0xF0);
Wire.send(0x55);
#endif
Wire.endTransmission();
delay(1);

Wire.beginTransmission(0x52);
#if (ARDUINO >= 100)
Wire.write(0xFB);
Wire.write(0x00);
#else
Wire.send(0xFB);
Wire.send(0x00);
#endif
Wire.endTransmission();

}

// Send a request for data to the nunchuck
// was "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52);    // transmit to device 0x52
#if (ARDUINO >= 100)
Wire.write(0x00);
#else
Wire.send(0x00);
#endif
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

#if (ARDUINO >= 100)
nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.read());
#else
nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());
#endif

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
}

// Print the input data we have recieved
// accel data is 10 bits long
// so we read 8 bits, then we have to add
// on the last 2 bits.  That is why I
// multiply them by 2 * 2
void nunchuck_print_data()
{
static int i=0;
int joy_x_axis = nunchuck_buf[0];
int joy_y_axis = nunchuck_buf[1];
int accel_x_axis = nunchuck_buf[2]; // * 2 * 2;
int accel_y_axis = nunchuck_buf[3]; // * 2 * 2;
int accel_z_axis = nunchuck_buf[4]; // * 2 * 2;

int z_button = 0;
int c_button = 0;

// byte nunchuck_buf[5] contains bits for z and c buttons
// it also contains the least significant bits for the accelerometer data
// so we have to check each bit of byte outbuf[5]
if ((nunchuck_buf[5] >> 0) & 1)
z_button = 1;
if ((nunchuck_buf[5] >> 1) & 1)
c_button = 1;

if ((nunchuck_buf[5] >> 2) & 1)
accel_x_axis += 2;
if ((nunchuck_buf[5] >> 3) & 1)
accel_x_axis += 1;

if ((nunchuck_buf[5] >> 4) & 1)
accel_y_axis += 2;
if ((nunchuck_buf[5] >> 5) & 1)
accel_y_axis += 1;

if ((nunchuck_buf[5] >> 6) & 1)
accel_z_axis += 2;
if ((nunchuck_buf[5] >> 7) & 1)
accel_z_axis += 1;

// Numera sequencialmente as linhas do log
//  Serial.print(i,DEC);
//  Serial.print("\t");

Serial.print(" joystick: ");
Serial.print(joy_x_axis,DEC);
Serial.print(",");
Serial.print(joy_y_axis, DEC);
Serial.print("  \t");

Serial.print("\t acc x:");
Serial.print(accel_x_axis, DEC);
Serial.print("\t\t y:");
Serial.print(accel_y_axis, DEC);
Serial.print("\t\t z:");
Serial.print(accel_z_axis, DEC);
Serial.print("\t");

Serial.print(" but:");
Serial.print(z_button, DEC);
Serial.print(",");
Serial.print(c_button, DEC);

Serial.print("\r\n");  // newline
i++;
}

// Encode data to format that most wiimote drivers except
// only needed if you use one of the regular wiimote drivers
char nunchuk_decode_byte (char x)
{
// x = (x ^ 0x17) + 0x17;
return x;
}

As diferenças são pequenas e estão em dois pontos do código: inicialização e leitura.

Inicialização

  • No original, é preciso escrever 0x00 no endereço 0x40;
  • No genérico que não suporta criptografia, é preciso escrever 0x00 no endereço 0xFB e 0x55 no endereço 0xF0.

Original

Wire.beginTransmission(0x52);// transmit to device 0x52
Wire.write(0x40);// sends memory address
Wire.write(0x00);// sends sent a zero.
Wire.endTransmission();// stop transmitting

Genérico

Wire.beginTransmission(0x52);      // endereço do nunchuck
Wire.write(0xF0);                    // registro de incialização 1
Wire.write(0x55);                  //dado
Wire.endTransmission();        //faz a transmissão
delay(1);
Wire.beginTransmission(0x52);
Wire.write(0xFB);                   // registro de incialização 2
Wire.write(0x00);                   //dado
Wire.endTransmission();             //faz a transmissão

Procure a função que faz a decodificação (geralmente procurar por “0x17” o levará direto a ela

uint8_t _nunchuk_decode_byte (uint8_t x)
{
x = (x ^ 0x17) + 0x17;
return x;
}

e desative a decodificação

uint8_t _nunchuk_decode_byte (uint8_t x)
{
//x = (x ^ 0x17) + 0x17;
return x;
}

Se você não desativar a decodificação o nunchuck parecerá funcionar, mas você encontrará dois problemas:

  • A leitura do acelerômetro ficará bagunçada;
  • O comportamento do botão Z ficará errado.

O adaptador wiichuck

A finalidade do adaptador wiichuck é meramente evitar que você precise cortar o conector original do nunchuck. Isso acelera bastante os testes com diferentes modelos de nunchuck (inclusive o que você conseguir emprestado), sem precisar danificá-lo.

Cuidado: conecte o nunchuck ao adaptador com o chanfro para cima, como mostrado na foto. Conectá-lo ao contrário vai inverter positivo e negativo da alimentação possivelmente destruindo o seu nunchuck.  Eu estou inclinado a acreditar que o nunchuck tenha proteção contra inversão de polaridade, porque é muito raro encontrar um alerta sobre isso. Porém nem todo nunchuck é igual (principalmente os genéricos) então é melhor prestar atenção à polaridade.

O wiichuck não funciona diretamente no arduino Mega. Para usá-lo no mega, faça as seguintes conexões com jumpers entre o wiichuck e o mega:

1: GND
2: 5V
3: SDA (pino 20)
4: SCL (pino 21)

Segurando o adaptador com a palavra “wiichuck” de pé, o pino 1 é o da esquerda.

Mas mesmo no Arduino UNO/Duemilanove o wiichuck depende um “truque” de programação para funcionar. Esse truque transforma as entradas analógicas A2 e A3 em pinos de alimentação. O código que faz isso se parece com este:

static void nunchuck_setpowerpins()
{
#define pwrpin PORTC3 //entrada A3
#define gndpin PORTC2 //entrada A2
DDRC |= _BV(pwrpin) | _BV(gndpin);
PORTC &=~ _BV(gndpin);
PORTC |=  _BV(pwrpin);
delay(100);  // wait for things to stabilize
}

Se você não estiver usando esse recurso, desative-o, ou não conseguirá usar as entradas A2 e A3 para outras coisas.

Links Úteis

Wiibrew – Explica a questão da criptografia, endereçamento, registros, etc.

Postado em Produtos | Tags: , | 7 Comments

Teclado membrana de 16 teclas com interface I2C

Este é o mesmo teclado membrana que eu já oferecia, agora com o acréscimo de um cabo que faz a interface I2C, reduzindo de oito para dois os pontos de i/o necessários.

Posso fornecer com endereços I2C de 0x20 a 0x26 (pode ser 0x27 também, mas evito usar este porque é o endereço fixo do meu display). Caso não seja especificado, será enviado com qualquer valor que eu tenha em estoque. O endereço é claramente marcado na região preta que envolve o circuito.

Minha convenção de cores na fiação que conecta ao Arduino (a interface mostrada na foto não segue esse padrão):

  • +5V: vermelho
  • GND: preto
  • SCL (CLOCK): Amarelo ou laranja
  • SDA (DATA): qualquer outra cor (geralmente branco)
  • INTERRUPT: Verde – Nem todos os meu teclados saem com esse fio. Ele sinaliza que houve uma mudança no estado das entradas. Na maioria dos casos você pode deixar solto.

O uso é bem simples.

Usando Arduino 0022:

Requer a biblioteca i2ckeypad de Angel Sancho.

Sketch adaptado do exemplo fornecido com a biblioteca.


#include <Wire.h>
#include <i2ckeypad.h>

#define linhas 4
#define colunas 4
#define endereco 0x20

i2ckeypad teclado = i2ckeypad(endereco, linhas, colunas);

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

Wire.begin();

teclado.init();

Serial.print("Testando Teclado I2C. Aperte teclas agora.\n\n");
}

void loop()
{
char key = teclado.get_key();

if(key != '\0') {
Serial.print(key);
}
}

Usando Arduino 1.0x
Você precisa da biblioteca Keypad_I2C, de Alexander Brevig
E do seguinte sketch:

/*
|| Adaptado do exemplo CustomKeypad de Alexander Brevig
*/
#include <Keypad_I2C.h>
#include <Keypad.h>
#include <Wire.h>

#define Endereco_I2C 0x20

const byte NumLinhas = 4;
const byte NumColunas = 4;
//Essa matriz tem que corresponder à aparência física do teclado
char hexaKeys[NumLinhas][NumColunas] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[NumLinhas] = {0, 1, 2, 3}; //Aqui você define que pinos estão ligados às linhas do teclado
byte colPins[NumColunas] = {4, 5, 6, 7}; //e aqui os pinos ligados às colunas

//inicializa uma instância da classe NewKeypad
Keypad_I2C customKeypad( makeKeymap(hexaKeys), rowPins, colPins, NumLinhas, NumColunas, Endereco_I2C);

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

void loop(){
  char customKey = customKeypad.getKey();

  if (customKey != NO_KEY){
    Serial.println(customKey);
  }
}

Cópias locais das bibliotecas:

Postado em Produtos | Tags: , | 6 Comments

Teclado membrana com 16 teclas

Os pinos foram identificados por mim na foto apenas. O teclado não tem as marcações.

Você precisa da biblioteca Keypad. Com ela,  o teclado pode ser ligado diretamente a oito pinos do Arduino, sem necessidade de qualquer outro componente. Atenção: a versão mais recente da biblioteca funciona com Arduino 0.2x ou 1.x, mas para que os exemplos apareçam na lista do Arduino 0.2x você precisa ir em cada diretório dentro de Examples e renomear os arquivos .ino para .pde.

Conecte o teclado aos pinos 2 a 9 do Arduino. Abra o exemplo keypad -> CustomKeypad e faça a seguinte modificação:


char hexaKeys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {2, 3, 4, 5}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {6, 7, 8, 9}; //connect to the column pinouts of the keypad

Abra o Serial Monitor. Cada tecla pressionada deve aparecer corretamente na porta serial.

Esta versão da biblioteca também permite detectar mais de uma tecla pressionada. Use este sketch para testar essa capacidade:

#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {2, 3, 4, 5}; //connect to the row pinouts of the kpd
byte colPins[COLS] = {6, 7, 8,9}; //connect to the column pinouts of the kpd

Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

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

void loop(){

if (kpd.getKeys())
{

for (int i=0; i<LIST_MAX; i++)   // Scan the entire list for any active keys.
{
if (kpd.key[i].kchar)    // Check for an active key.
{
switch (kpd.key[i].kstate) {
case HOLD:
Serial.print("Key ");
Serial.print(kpd.key[i].kchar);
Serial.print(" is being HELD and the state ");
if (!kpd.key[i].stateChanged)
Serial.println("has not changed.");
else
Serial.println("has changed.");
break;
case PRESSED:
Serial.print("Key ");
Serial.print(kpd.key[i].kchar);
Serial.print(" is PRESSED and the state ");
if (!kpd.key[i].stateChanged)
Serial.println("has not changed.");
else
Serial.println("has changed.");
break;
case RELEASED:
Serial.print("Key ");
Serial.print(kpd.key[i].kchar);
Serial.print(" has been RELEASED and the state ");
if (!kpd.key[i].stateChanged)
Serial.println("has not changed.");
else
Serial.println("has changed.");
break;
default:
Serial.print("Key ");
Serial.print(kpd.key[i].kchar);
Serial.print(" is IDLE and the state ");
if (!kpd.key[i].stateChanged)
Serial.println("has not changed.");
else
Serial.println("has changed.");
}
}
}
}
}
Postado em Produtos | Tags: | 1 Comment

Usando a touchscreen de 4 fios

Este post se refere ao meu item que é uma touchscreen apenas (a placa transparente) e não ao LCD com touchscreen.

Muito cuidado é necessário ao manusear a tela. Ela pode ser inutilizada por qualquer queda, principalmente se bater “de quina”.

Você pode usar a biblioteca da Adafruit ou a do livro Practical Arduino. A da Adafruit funcionou melhor nos meus testes e é mais flexível, pois também mede pressão e permite que você use duas portas digitas e duas analógicas ou quatro analógicas. A do livro requer que você use quatro analógicas.

Material de referência:

AVR341 – Documento da Atmel que explica como touchscreens resistivas de quatro e cinco fios funcionam, com exemplos de código para AVR.

Practical Arduino – Páginas 121 a 137

Postado em Informação | Tags: | Deixe um comentário

Kit de controle remoto infravermelho

infrared_remote_kit_IMG_1083_automalabs.com.br

Atenção

Ao trabalhar com o receptor IR, dois cuidados precisam ser tomados:

  • Providencie alimentação extra para o Arduino. Apenas alimentá-lo pela USB pode não ser suficiente;
  • Abrigue o receptor da luz ambiente. Faça com que ele fique “na sombra”. Iluminação fluorescente, principalmente eletrônica, pode interferir com o funcionamento do receptor. Perceba que em quase todo aparelho que usa IR o receptor fica oculto atrás de um “filtro” escuro e muitas vezes recuado. Isso é para evitar que ele veja a luz ambiente.

Nos dois casos acima, o sintoma de problemas é que o comando falha 50% das vezes ou mais.

Seu transmissor pode eventualmente ser entregue ainda com o isolador no compartimento de bateria. É uma pequena lâmina de plástico que fica saliente. Retire totalmente (pode jogar fora) para que a bateria faça contato. Isso é colocado na fábrica para evitar que a bateria descarregue se um botão ficar pressionado durante o transporte.

Para testar o transmissor, use uma câmera digital qualquer. Aponte o controle para a câmera e veja se o LED está acendendo quando você aperta um botão.

Tabela de códigos do transmissor (códigos NEC de 32 bits compatíveis com a biblioteca IRremote):

  • FFA25D = Power
  • FF629D = Mode
  • FFE21D = Mute
  • FF22DD = Play/Pause
  • FF02FD = Previous
  • FFC23D = Next
  • FFE01F = EQ
  • FFA857 = “-“
  • FF906F = “+”
  • FF6897 = 0
  • FF9867 = Repeat
  • FFB04F = USB/SD
  • FF30CF = 1
  • FF18E7 = 2
  • FF7A85 = 3
  • FF10EF = 4
  • FF38C7 = 5
  • FF5AA5 = 6
  • FF42BD = 7
  • FF4AB5 = 8
  • FF52AD = 9

O transmissor usa “repeat codes”. Para que o Arduino detecte que botão você apertou e segurou é necessário que seu sketch tenha decodificado com sucesso a primeira transmissão e ao receber os repeat codes “enxergue-os” como o código anterior. Sketches que não sabem lidar com repeat codes dirão que o código recebido é “FFFFFF”.

Explicando de outra forma:

Quando você aperta e segura um botão do remoto, ele transmite uma vez o código correspondente à tecla e depois fica transmitindo o “repeat code” até você soltar o botão. Se o arduino perder essa primeira transmissão, não há como ele identificar que botão você está segurando, por mais que você aponte para o receptor.

O que estou explicando aqui aplica-se ao transmissor fornecido no kit, que usa um protocolo parecido com JVC e NEC.

Datasheet do receptor IRM8601

IRM8601 - Infrared Remote Control Receiver
IRM8601 - Infrared Remote Control Receiver
IRM8601 - Infrared remote control receiver.pdf
242.4 KiB
667 Downloads
Detalhes...
Postado em Produtos | Tags: , , | 1 Comment

Arduino Shield 1602 com keypad


Peso: 56g

  


Documentação geral

Diagrama

É possível usar este shield em conjunto com o shield ethernet Wiznet W5100, mas para isso é necessário entortar ou cortar o pino 10 do shield LCD, porque conflita com o Wiznet. Essa desconexão apenas elimina a possibilidade de desligar o backlight do shield LCD.

Arduino 1.01 a 1.05  (usando biblioteca oficial)

Em cada um dos exemplos da biblioteca LiquidCrystal, basta mudar


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

por

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

Arduino 1.01 a 1.05  (se quiser usar programas que usam LCD4bit_mod)

Instale a biblioteca LCD4bit_mod normalmente e depois faça a seguinte alteração no arquivo LCD4Bit_mod.cpp:

troque

#include "LCD4Bit_mod.h"
extern "C" {
  #include <stdio.h>  //not needed yet
  #include <string.h> //needed for strlen()
  #include <inttypes.h>
  #include "WConstants.h"  //all things wiring / arduino
}

por

#include "LCD4Bit_mod.h"
#if (ARDUINO < 100)
  extern "C" {
    #include <stdio.h>  //not needed yet
    #include <string.h> //needed for strlen()
    #include <inttypes.h>
    #include "WProgram.h"
  }
#else
  #include <Arduino.h>
#endif

Arduino 002x

Instale a biblioteca LCD4bit_mod. Ela já vem com exemplos.

Postado em Produtos | Tags: , , , | 1 Comment