PLUG

Bom, depois de andar a remexer um pouco, aproveitei o facto de ter que tirar para fora o teclado da Vending para o fotografar.

[align=center][img width=400]http://www.brickshelf.com/gallery/blu3- ... /first.jpg[/img][/align]

http://www.brickshelf.com/cgi-bin/gallery.cgi?f=368899

Foi a maneira mais simples que usei para fazer um teclado simples e funcional. É praticamente feito inteiramente em LEGO.

O truque é usar pequenas resistências, embutidas dentro dos cabos 9v antigos. Limitei-me a afastar os dois fios que estão colados um ao outro, cortando muito pouco de um deles, cerca de 0.5cm. Cortei as pontas das resistências de modo a sobrar muito pouco para fora da resistência em si,  para enfiar dentro do cabo com relativa facilidade, matendo o contacto entre as pernas da resistência e os fios elécticos que passam dentro do cabo.

[img width=400]http://www.brickshelf.com/gallery/blu3- ... ct2624.jpg[/img]

Acondicionei mais ou menos com fita-cola, liguei os vários sensores de tacto uns aos outros e depois, com um cabo apenas, faço a ligação a uma porta de sensores, input, do RCX ou do NXT (com o cabo de conversão).

A programar, leio como sendo um sensor de luz, no modo de percentagem.

Teoricamente, poderei ter até 100 teclas (0-100%). No entanto, por vezes, é complicado acertar com as resistências que dão exactamente a percentagem que queremos. Não sei precisar o intervalo de valores de resistências que se podem usar, mas em casa posso tentar encontrar e colocar aqui.

---

Sugestão de Programa (na linguagem NXC)

Vamos meter também um pouco de programação à mistura!

Aqui fica a minha sugestão para obter a tecla pressionada:

int GetKey()
{
int KEY = 0;           // KEY e key_aux tem de ter valores diferentes para nao saltar o ciclo "while"
int key_aux = 10;

while(SENSOR_4 > 0);   // No caso da funcao arrancar com alguem a pressionar uma tecla, espera ate que seja liberta
Wait(150);
while(SENSOR_4 == 0);   // Espera ate que uma tecla seja pressionada e o sensor deixe de retornar "0"
Wait(20);

while(KEY != key_aux)
{
  Wait(30);
  switch(SENSOR_4)  // Consoante o valor do SENSOR_4, assim se atribui a tecla (KEY) correspondente
  {
   case 12: KEY = 1; break;
   case 18: KEY = 2; break;
   case 19: KEY = 2; break;
   case 26: KEY = 3; break;
   case 45: KEY = 4; break;
   case 55: KEY = 5; break;
   case 79: KEY = 6; break; // R (Return) key
   case 2: KEY = 7; break;  // Water key
   case 7: KEY = 8; break;  // Juice key
  }
  Wait(30);
  switch(SENSOR_4)  // Volta-se a fazer o mesmo que em cima descrito mas para uma variavel auxiliar (key_aux)
  {
   case 12: key_aux = 1; break;
   case 18: key_aux = 2; break;
   case 19: key_aux = 2; break;
   case 26: key_aux = 3; break;
   case 45: key_aux = 4; break;
   case 55: key_aux = 5; break;
   case 79: key_aux = 6; break; // R (Return) key
   case 2: key_aux = 7; break;  // Water key
   case 7: key_aux = 8; break;  // Juice key
  }
}                 // Em fim de loop (ciclo) verifica se KEY e key_aux sao iguais. Em caso afirmativo retorna a tecla determinada. Caso contrario, repete o ciclo ate haver coerencia.

return KEY;
}

task main(void)
{
int tecla;
SetSensorType(S4, SENSOR_TYPE_LIGHT);
SetSensorMode(S4, SENSOR_MODE_PERCENT);
while(1)
{
  tecla = GetKey();
  //codigo para mostrar valor de "tecla" no ecra
}
}

Espero que esteja mais ou menos explícito, quer para quem saiba programar, quer não!

O que fizeste com as resistências nos cabos é o que a LEGO fez com os sensores de toque do CyberMaster (daí as cores diferentes deles), mas em maior número!

Quanto à programação, não sei se configurar a porta para sensor de luz será adequado... o pBrick coloca-a em modo activo, com os ciclos de alimentação e leitura de valores: não sei se assim gastará mais bateria que em modo passivo. E se puderes em modo RAW, então em teoria consegues em teoria ler 1023 botões!
E acho esquisito o programa fazer duas leituras quase iguais das teclas; mas tenho de analisar isso com calma.

Pois, já tivemos essa conversa da alimentação enquanto sensor de luz... mas olha, nunca tive problemas. Para já continuo a usar assim...

Quanto às duas leituras consecutivas é apenas para evitar alguns enganos. Com os comandos de Wait() dou um tempo para que o valor se ajuste antes de fazer nova leitura. Se tiver apenas uma leitura, se por azar durante o pressionar da tecla acertar num outro valor que não o "estabilizado", estou a fazer uma leitura incorrecta.

É que se reparares, quando pressionas um sensor de tacto, devagarinho, obtens por vezes valores diferentes de 100%, que é o esperado quando pressionas totalmente o sensor.


Para optimizar o programa, a verificação do while deveria ser feita também a seguir a primeira leitura (no switch), para o caso de por exemplo a segunda leitura (2a posição no while) coincidir com a terceira leitura (1a posição no while)

Vou utilizar este tópico antigo para partilhar a nova criação do Jason Alleman que como já devem ter imaginado, é um teclado! Infelizmente, não tem é nada de Mindstorms...