Modulo Infravermelho YS-IRTM

Modulo Sensor/Atuador Infravermelho YS-IRTM

O módulo infravermelho possui um sensor e um emissor infravermelho para comunicação com aparelhos eletrônicos que usem a codificação NEC.

O protocolo NEC está descrito em detalhes no artigo:

http://www.sbprojects.com/knowledge/ir/nec.php

Um comando é transmitido apenas uma vez, mesmo quando a tecla no controle remoto permanece pressionada. A cada 110 ms um código de repetição é transmitido enquanto a tecla permanece pressionada. Este código de repetição é simplesmente um pulso AGC de 9ms seguido por um espaço de 2,25ms e uma rajada de 560μs.

Mas tudo isso é detalhe, pois o módulo realiza esta (de)codificação automaticamente e a comunicação é feita através de duas linhas seriais, TX e RX, que podem ser ligadas, respectivamente, nas linhas RX e TX do Arduino Galileo/Uno. A pinagem está definida claramente na serigrafia da placa do módulo, cuja alimentação é de 5 Volts.

Use preferencialmente no Arduino as portas 2 (RX)  e 3 (TX), que e podem ser acessadas com a biblioteca Serial2. Caso você utilize uma versão diferente de Arduino, pode usar as portas 0 (RX)  e 1 (TX) para esta função e a biblioteca Serial.

Para transmissão, por exemplo, de um sinal codificado 1C 2F 33, enviar a seguinte sequência para a saída TX:  {A1, F1,1C, 2F, 33}.

A velocidade padrão de comunicação da porta serial do módulo é de 9600 bauds, mas é possível alterar essa velocidade  por exemplo, para 57600 bauds, com o comando {A1, F3,04,00,00}, onde o terceiro byte é codificado com a seguinte tabela:

01 - 4800 bps
02 - 9600 bps
03 - 19200bps
04 - 57600bps

Para receber um código, basta apenas receber os dados pela porta serial. Quando fazemos a operação de decodificação, só precisa apontar o controle remoto para o receptor infravermelho, pressionar o botão para ser decodificado, para ver o resultado de decodificação pelo assistente de depuração de serial, o resultado é uma saída como “Código do usuário 1 + Código de Usuário 2 + código de comando”. 

Então, se você receber o código 04 FB 12, para enviar o mesmo código usando o módulo YS-IRTM, você tem que enviar os  "start" bytes A1, F1 primeiro. Então, o código para ser enviado deve parecer como  A1 F1 04 FB 12. 

Veja maiores detalhes:

 https://forum.arduino.cc/index.php?topic=359707.0

Para a programaçãoem Javascript, com uso do Johnny-five, não há API disponĩvel para este módulo. É necessário então o uso da rotina de comunicação serial da biblioteca StandardFimataPlus, já que na biblioteca StandardFirmata, as interfaces serias não estão habilitadas.

Veja o exemplo de teste a seguir:

var Board = require("firmata");

Board.requestPort(function(error, port) {

if (error) {

console.log(error);

return;

}

var board = new Board(port.comName);

board.on("ready", function() {

console.log("READY");

var HW_SERIAL1 = board.SERIAL_PORT_IDs.HW_SERIAL1;

var maxBytesToRead = 4;

board.serialConfig({

portId: HW_SERIAL1,

baud: 9600

});

// leave 2nd parameter (maxBytesToRead) to read all available bytes in buffer

// board.serialRead(HW_SERIAL1, maxBytesToRead, function(data) {

board.serialRead(HW_SERIAL1, function(data) {

console.log(new Buffer(data).toString("hex"));

});

board.on("string", function (message) {

console.log(message);

});

// log serial pin numbers

for (var pin in board.pins) {

var modes = board.pins[pin].supportedModes;

for (var mode in modes) {

if (modes[mode] === board.MODES.SERIAL) {

console.log("serial pin: " + pin);

}

}

}

});

});


 

JSON

O JSON (JavaScript Object Notation) é um formato de troca de dados. Para seres humanos, é fácil de ler e escrever. Para máquinas, é fácil de interpretar e gerar. Está baseado em um subconjunto da linguagem de programação JavaScript.

O JSON é apresentado em formato texto e completamente independente de linguagem, pois usa convenções que são familiares a diversas linguagens, incluindo C, C++, C#, Java, JavaScript, Perl, Python, entre outras. O JSON é constituído de duas estruturas:

• Uma coleção de pares nome/valor. Em várias linguagens, isto é caracterizado como um objeto, registro, estrutura, dicionário, etc.
• Uma lista ordenada de valores. Na maioria das linguagens, isto é caracterizado como um arranjo, vetor, lista ou sequência.

São estruturas de dados universais. Virtualmente todas as linguagens de programação modernas as suportam, de uma forma ou de outra. É aceitável que um formato de troca de dados que seja independente de linguagem de programação se baseie nestas estruturas. Em JSON, os dados são
apresentados desta forma:

• Um objeto é um conjunto desordenado de pares nome/valor.
• Um objeto começa com  (chave de abertura) e termina com  (chave de fechamento).
• Cada nome é seguido por : (dois pontos) e os pares nome/valor são seguidos por , (vírgula).

• Um array é uma coleção de valores ordenados. O array começa com [ (colchete de abertura) e termina com ] (colchete de fechamento). Os valores são separados por , (vírgula).

• Um valor pode ser uma cadeia de caracteres (string), ou um número, ou true ou false, ou null, ou um objeto ou um array. Estas estruturas podem estar aninhadas.

• Uma string é uma coleção de nenhum ou mais caracteres unicode, entre aspas duplas, usando barras invertidas como caractere de escape. Um caractere está representado como um simples caractere de string. Uma cadeia de caracteres é parecida com uma cadeia de caracteres em C ou Java.

• Um número é similar a um número em C ou Java, exceto quando não se usa os números octais ou hexadecimais.

object
         {}
         { members }
members
         pair
         pair , members
pair
         string : value
array
         []
         [ elements ]
elements
         value
         value , elements
value
         string
         number
         object
         array
         true
         false
         null
string
         ""
         " chars "
chars
         char
         char chars
char
         any-Unicode-character-
                     except-"-or-\-or-
                  control-character
          \"
         \\
         \/
         \b
         \f
         \n
         \r
         \t 
         \u four-hex-digits
number
         int
         int frac
         int exp
         int frac exp
int
         digit
         digit1-9 digits
         - digit
         - digit1-9 digits
frac
         . digits
exp
         e digits
         digits
digit
         digit digits
e
         e
         e+
         e-
         E
         E+
         E-

Recursividade em Funções

O JavaScript permite que você chame funções recursivamente. Isso é particularmente útil para lidar com estruturas de árvore, como as encontradas no DOM do navegador.

function countChars(elm) {
if (elm.nodeType == 3) { // TEXT_NODE
return elm.nodeValue.length;
}
var count = 0;
for (var i = 0, child; child = elm.childNodes[i]; i++) {
count += countChars(child);
}
return count;
}

Observe que as funções JavaScript são objetos - como tudo o mais em JavaScript - e você pode adicionar ou alterar suas propriedades, como vimos anteriormente.

Funções anexadas a Objetos

Vamos criar duas funções para exibir o nome de uma pessoa. Basicamente há duas maneiras pelas quais o nome pode ser exibido: como "primeiro último"ou como "último, primeiro". Usando as funções e objetos que discutimos anteriormente, poderíamos exibir os dados como este:

function criaPessoa(primeiro, ultimo) {
return {
primeiro: primeiro,
ultimmo: ultimo,
Nomecompleto: function() {
 return this.primeiro + ’ ’ + this.ultimo;
},
NomecompletoReverso: function() {
return this.ultimo + ’, ’ + this.primeiro;
}
};
}
s = criaPessoa(‘Wilson’ ,’Simonal’);
s.Nomecompleto(); // "Wlson Simonal"
s.NomecompletoReverso(); // "Simonal, Wilson"


Podemos aproveitar a palavra-chave this para melhorar nossa função criaPessoa:

function Pessoa(primeiro, ultimo) {
this.primeiro = primeiro;
this.ultimo = ultimo;
this.Nomecomplero = function() {
return this.primeiro + ’ ’ + this.ultimo;
};
this.NomecompletoReverso = function() {
return this.ultimo + ’, ’ + this.primeiro;
};
}
var s = new Pessoa(’Wilson’,’Simonal’);

Introduzimos outra palavra-chave: new. Ela cria um novo objeto vazio e, em seguida, chama a função especificada, com este conjunto para esse novo objeto. Por exemplo:

function Pessoa(primeiro, ultimo, idade, olhos) {
this.primeiroNome = primeiro;
this.ultimoNome = ultimo;
this.idade = idade;
this.corOlhos = olhos;
this.nome = function() {return this.primeiroNome + " " + this.ultimoNome;};
}
var s = new Pessoa(’Wilson’,’Simonal’, 18, ’blue’);
console.log(s.primeiroNome);
console.log(s.ultimoNome);
console.log(s.nome());

Esta função pode ainda ser melhorada criando-se as funções do método apenas uma vez, e atribuindo referências a elas dentro do construtor.

function pessoaNomeCompleto() {
return this.primeiro + ’ ’ + this.ultimo;
}
function pessoaNomeCompletoReverso() {
return this.ultimo + ’, ’ + this.primeiro;
}
function Pessoa(primeiro, ultimo) {
this.primeiro = primeiro;
this.ultimo = ultimo;
this.Nomecompleto = pessoaNomeCompleto;
this.NomecompletoReverso = pessoaNomeCompletoReverso;
}

Protótipos de Funções

Podemos também criar um protótipo de função, que depois pode ser utiilzado para criar diversos tipos de objetos.

function Pessoa(primeiro, ultimo) {
this.primeiro = ultimo;
this.ultimo = ultimo;
}
Pessoa.prototype.Nomecompleto = function() {
return this.primeiro + ’ ’ + this.ultimo;
};
Pessoa.prototype.NomecompletoReverso = function() {
return this.ultimo + ’, ’ + this.primeiro;
};
var s = new Pessoa(’Wilson’,’Simonal’);
console.log(s.primeiro);
console.log(s.ultimo);
console.log(s.Nomecompleto());
console.log(s.NomecompletoReverso());

Funções

Uma função JavaScript pode ter 0 ou mais parâmetros nomeados. O corpo da função pode conter tantas declarações quanto você quiser, e variáveis que são locais para aquela função podem ser declaradas no corpo da função. A declaração return pode ser usada para retornar um valor a qualquer momento, terminando a função.

function soma(num1,num2) {
var resultado = num1 + num2;
return resultado;
}
soma(4,7);
soma(20,20);
soma(0.5,3);

Se nenhuma declaração de retorno for usada (ou um return vazio sem nenhum valor), o JavaScript retornará o valor undefined.

Os parâmetros enumerados revelam-se mais como orientações do que qualquer outra coisa. Você pode chamar uma função sem passar os parâmetros que espera, caso em que eles serão definidos como undefined.

soma(); // NaN
// Não se pode realizar a soma em um undefined

Você também pode passar mais argumentos do que a função está esperando:

soma(2, 3, 4); // 5
// somou os dois primeiros argumentos; 4 foi ignorado

Argumentos de Funções

Isso pode parecer um pouco bobo, mas as funções têm acesso a uma variável adicional dentro de seu corpo chamada argument, que é um objeto do tipo array contendo todos os valores passados para a função. Vamos re-escrever a função soma para receber quantos valores quisermos:

function soma() {
var resultado = 0;
for (var i = 0, j = arguments.length; i < j; i++) {
resultado += arguments[i];
}
return resultado;
}
soma(2, 3, 4, 5); // 14

Isso realmente não é mais útil do que apenas escrever 2 + 3 + 4 + 5.  Vamos criar então uma função que calcule a média:

function media() {
var soma = 0;
for (var i = 0, j = arguments.length; i < j; i++) {
soma += arguments[i];
}
return soma / arguments.length;
}
media(2, 3, 4, 5); // 3.5

Operador Spread

O operador spread é usado em declarações de função com o formato: ... [variável] e incluirá dentro dessa variável toda a lista de argumentos não capturados com os quais a função foi chamada. Vamos também substituir o laço for por um laço for ... of para retornar os valores dentro de nossa variável.

function media(...argumentos) {
var soma = 0;
for (let valor of argumentos) {
soma += valor;
}
return soma / argumentos.length;
}
media(2, 3, 4, 5); // 3.5

Funções Anônimas

O JavaScript permite que você crie funções anônimas.

var avg = function() {
var sum = 0;
for (var i = 0, j = arguments.length; i < j; i++) {
sum += arguments[i];
}
return sum / arguments.length;
};

Objetos

Há duas formas básicas para se criar um objeto vazio:

var obj = new Object();     
var obj = {};

Essas formas são semanticamente equivalentes e a segunda é chamada sintaxe literal do objeto e é mais conveniente. Esta sintaxe também é o núcleo do formato JSON e deve ser preferida todas as vezes. A sintaxe literal do objeto pode ser usada para iniciar um objeto em sua totalidade.

var obj = {
name: ’Cenoura’,
for: ’Mario’,
details: {
color: ’laranja’,
size: 12
}
}

Atributos dos objetos podem ser encadeados juntos:

obj.details.color; // orange
obj[’details’][’size’]; // 12

Os exemplos a seguir criam um protótipo de um objeto, Pessoa, e uma instância deste protótipo,Voce.

function Pessoa(nome, idade) {
this.nome = nome;
this.idade = idade;
}
 
// Define um objeto
var Voce = new Pessoa(’Voce’, 24);
// Estamos criando uma nova pessoa de nome  "Voce”
// com a idade igual a 24

Uma vez criado, as propriedades de um objeto podem ser criadas de dois modos:

obj.nome = ’Simonal’;
var nome = obj.nome;

E ...

obj[’nome’] = ’Simonal’;
var nome = obj[’nome’];

Essas formas também são semanticamente equivalentes. O segundo método tem a vantagem que o nome da propriedade é fornecido como uma string, o que significa que ela pode ser calculada em tempo de execução.

Contudo, o uso deste método previne que algumas máquinas Javascript utilizem certas otimizações de minimização. Esta forma também pode ser usada para atribuir propriedades com nomes que
são palavras reservadas no Javascript:

obj.for = ’Simonal’; // Erro de sintaxe, porque ’for’ é uma
// palavra reservada
obj[’for’] = ’Simonal’; // Funciona sem problemas

Eventos

Eventos em HTML sao "coisas"que acontecem com os elementos HTML.  Quando o Javascript é utilizado em páginas HTML, ele pode "reagir"a esses eventos. Um evento HTML pode ser alguma coisa que o navegador faz, pode ser algo que o usuário faz. Veja a seguir alguns exemplos de eventos em HTML:

• Uma página HTML que acabou de carregar;
• Um campo de entrada HTMl que mudou de valor;
• Um botão HTML que foi pressionado.

Frequentemente, quando um evento acontece, você pode querer fazer alguma coisa. O JavaScript permite que você execute código quando eventos são detectados. Veja a seguir:

document.querySelector(’html’).onclick = function() {
alert(’Ai! Não me cutuque!’);
}

Há muitas maneiras de conectar um evento com um elemento.  Aqui o elemento HTML foi selecionado, atribuindo ao manipulador
onclick a uma função anônima, que contém o código que
queremos executar. Note que

document.querySelector(’html’).onclick = function() {};

é equivalente a

var myHTML = document.querySelector(’html’);
myHTML.onclick = function() {};

O HTML permite que atribitos de manipuladores de evento,m com código Javascript, sejam adicionados aos elementos HTML.

Com aspas simples:

<element event=’codigo JavaScript’>
 
Com aspas duplas:

<element event="codigo JavaScript»>

No exemplo seguinte, um atributo onclick (com código) é adicionado ao elemento but on em HTML:

<button onclick="document.getElementById(’demo’).innerHTML = Date()">Que horas são?</button>

No exemplo acima, o Javascriot muda o conteúdo do elemento com id="demo". No próximo exemplo, o código muda o conteúdo de seu próprio elemento (usando this.innerHTML):

<button onclick="this.innerHTML = Date()">Que horas são?</button>

O código JavaScript frequentemente tem várias linhas de código. É cada vez mais comum vermos atributos de eventos chamando funções:

<button onclick="displayDate()"> Que horas são?</button>

A seguir uma lista de alguns elementos HTML usuais:

Os  manipuladores de evento podem ser utilizados para manipular e verificar a entrada de dados do usuário, ações do usuário e ações do navegador:

• Coisas que devem ser feitas toda vez que uma página é carregada;
• Coisas que devem ser feitas quando uma página é fechada;
• Ações que devem ser realizadas quando um usuário clica um botão;
• Conteúdo que deve ser verificado quando o usuário faz uma entrada de dados.
• E mais...

Sentenças Condicionais e Laços

if-then-else

O uso de sentenças condicionais, assim como em outras linguagens, também é possível em Javascript. A seguir um exemplo que apresenta o resultado na console.

if (time < 10) {
saudacao = "Bom dia!";
} else if (time < 20) {
saudacao = "Boa tarde!";
} else {
saudacao = "Boa noite!";
}
console.log(saudacao);
...
var name = ’gatinho’;
if (name == ’toto’) {
name += ’ auau’;
} else if (name == ’gatinho’) {
name += ’ miau
} else {
name += ’!’;
}
console.log(name);

Laços com while e for

Para iterar diversas vezes podem ser utilizados o for e o
while. Inicialmente, vejamos um exemplo com while:

while (true) {
// um laço infinito!
}
var input;
do {
input = get_input();
} while (inputIsNotValid(input));

 
E agora exemplo com for:

for (var i = 0; i < 5; i++) {
// vai executar 5 vezes
}
for (let value of array) {
// faça alguma coisa com o valor
}
for (let property in object) {
// faça alguma coisa com a propriedade do objeto
}

Switch

O comando switch pode ser usado para fazer uma escolha entre diversos itens, sem que seja necessário o uso do if-then-else.

switch (sinal) {
case ’verde’:
Siga();
break;
case ’vermelho’:
Pare();
break;
case ’amarelo’:
Reduza();
break;
default:
Pare();
}