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();
}

Conversão de Tipos

Conversão Implícita de Tipos

Em expressões envolvendo valores numéricos e strings com o operador +, os valores numéricos serão convertidos implicitamente para strings. Por exemplo::

X = "A resposta é " + 35; // retorna "A resposta é 35"
Y = 35 + " é a resposta" // retorna "35 é a resposta"

Em expressões envolvendo outros operadores a conversão será feita de acordo com o tipo de dado esperado pelo operador. Exemplo:

X = "37" - 7 // retorna 30
Y = "37" + 7 // retorna 377

Quando dois valores são comparados, números, strings e valores lógicos são comparados por valor:

3 == "3" // Resultado true
1 && true // Resultado true

Usando a conversão implícita podemos usar de um artifício simples para forçar a conversão de número para string e de string para número.

Número para string:

i = 25 ;
s = "" + i ; // s recebe "25"

String para número:

s = "256" ;
j = s - 0 ; // j recebe 256

Conversão de Explícita de Tipos

parseInt (str) ou parseInt (str,base): Converte uma string num número inteiro. Str é a cadeia a ser convertida e base é a base em que os números estão codificados. Se a base não for especificada,
assume que a string é uma seqüência de algarismos na base decimal (0,1,2,3,4,5,6,7,8,9). Caso encontre algum caractere diferente dos esperados, encerra a conversão:

num = "3A";
x = parseInt(num);    // x recebe 3
y = parseInt(num,16);    // y recebe 58

parseFloat (str): É a função equivalente a parseInt, para converter strings em números reais. Da mesma forma, se encontrar algum caractere não esperado, encerra a conversão.

z = parseFloat("3.15"); // z recebe 3.15

Tipos de Dados

 Relacionamos alguns tipos de dados de uso mais comum em Javascript.

Arrays

Arrays são um tipo de dados muito importantes em qualquer linguagem. Uma maneira de criar e declarar arrays em Javascript pode ser a seguinte:

var a = new Array();
a[0] = ’cao’;
a[1] = ’gato’;
a[2] = ’frango’;
a.length; // 3

Uma notação mais conveniente é usar um array de literais:

var a = [’cao’, ’gato’, ’frango’];
a.length; // 3

Se você acessar um índice de array que não existe, o valor undefined será retornado:

typeof a[90]; // undefined

Você pode iterar sobre os elementos de um array usando um laço do tipo for e o método a.length, que retorna o tamanho de um array:

var a=[0,1,2,3,4,5,6,7,8,9,0];
for (var i = 0; i < a.length; i++) {
console.log(a[i]);
}

Um outro modo de iterar sobre os elementos de um array foi adicionado recentemente à definição da linguagem:

a=[9,8,7,6,5,4,3,2,1];
a.forEach (function(temp, i, novo) {
console.log(a[i]);
console.log(temp);
console.log(novo);
});

Se você quiser adicionar um elemento ao array simplesmente use o seguinte método pré-definido para arrays na linguagem:

a.push(item);


Métodos Pré-Definidos para Array

• a.toString() : Retorna uma cadeia com a toString() de cada elemento separadas por vírgula.
• a.toLocaleString(): Retorna uma cadeia com a toLocaleString() de cada elemento separadas por vírgula.
• a.concat(item1[, item2[, ...[, itemN]]]): Retorna um novo array com os novos itens adicionados ao antigo.
• a.join(sep): Converte o array em uma cadeia – com os valores delimitados com o parâmetro sep
• a.pop() : Remove e retorna o último ítem.
• a.push(item1, ..., itemN): Adiciona uma ou mais itens ao final do array.
• a.reverse(): Inverte o array.
• a.shift(): Remove e retorna o primeiro item.
• a.slice(start[, end]): Retorna um sub-array.
• a.sort([cmpfn]): Ordena o array com o uso de uma uma função de comparação (opcional) passada como parâmetro.
• a.splice(start, delcount[, item1[, ...[, itemN]]]): Permite que você modifique um array apagando uma seção dele e substituindo com outros itens.
• a.unshift (item1[, item2[, ...[, itemN]]]): Adiciona itens ao início do array.

Operadores

A seguir apresentamos alguns dos operadores mais utilizados na linguagem Javascript. Em particular, notem a diferença entre == e ===, onde o segundo operador exige que as variáveis sendo comparadas sejam do mesmo tipo para que a igualdade seja verdadeira e no primeiro caso não.

Entrada e Saída

 A entrada e saída pode ser realizada basicamente de duas formas:

• No navegador 
• window.prompt: Abre uma janela para pedir uma string ao usuário

       nome = window.prompt("Digite o seu nome:", "");

• window.alert: Abre uma janela para exibir um aviso ao usuário

             window.alert("Senha inválida.");

• No node.js ou na console
• console.log: Imprime um valor na console

            console.log('Alô!');

Variáveis e Comentários

O nomes em JavaScript  são sensíveis ao caixa alto ou baixo: myVariable é diferente de myvariable.

    var myVariable;
    myVariable = 'Bob';
    var myVariable = 'Bob';
    myVariable = 'Steve';



Comentários:

/*
Tudo o que estiver aqui é comentário
*/

// Isto também é um comentário
// que pode ser feito desta maneira
// se você quiser

Package.json

O aqruivo package.json

O arquivo package.json está presente  no diretório raiz de qualquer aplicação/módulo Node e é utilizado para definir as propriedades de um pacote. Veja ume xemplo a seguir:

{
  "name": "teste",
  "version": "1.0.0",
  "description": "",
  "main": "webteste.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.15.3",
    "johnny-five": "^0.11.1"
  }
}

Atributos do Package.json

• name − nome do pacote
• version − versão do pacote
• description − descrição do pacote
• homepage − homepage do pacote (URL)
• author − autor do pacote
• contributors − nome dos colabores do pacote
• dependencies − lista de dependências. O NPM automaticamente instala as dependências mencionadas aqui no diretório node_module do pacote.
• repository − tipo do repositório e URL do pacote
• main − pponto de entrada do pacote
• keywords −palavras-chave.

Gerenciando a cache npm

Para atualizar um pacote node.js que já está instalado, o seguinte comando pode ser utilizado:

$ npm update johnny-five
Quando o  npm instala um pacote ele guarda uma cópia deste pacote, de modo que na próxima vez que você precisar deste pacote, não seja necessário ir à internet novamente.

O diretório onde esta cópia é guardada é  ~/.npm no Posix, ou \%AppData\%/npm-cache no Windows.

Eventualmente este diretório pode ficar cheio com pacotes velhos, então é necessário que ele seja limpo de vez em quando com o comando:

$ npm cache clean

Para utilizar um módulo no seu arquivo js, inclua a linha como a seguir:

var express  = require ('prompt');

As regras de onde “require” encontra os arquivos podem ser um pouco complexas, mas uma regra simples é que se o arquivo não começa com "./" ou "/", então ele é considerado um módulo global (e o caminho de instalação do “Node” local é verificado), ou é uma dependência local na pasta  “node\_modules” do projeto local. 

Se o arquivo começa com "./" é considerado um arquivo relativo ao diretório do arquivo que chamou “require”. Se o arquivo começa com "/", ele é considerado um caminho absoluto.

OBSERVAÇÃO: você pode omitir a extensão ".js" e a função “require” irá automaticamente anexá-la se necessário.

npm

O Node Package Manager (npm) fornece duas funcionalidades principais:

• Repositórios online para pacotes e módulos node.js que podem ser localizados em http://search.nodejs.org
• Utilitários de linha de comando para instalar pacotes node.js, fazendo o gerenciamento de versões e dependências.

O npm é instalado junto com o node.js.  Para verificar qual a sua versão, abra a console (ou execute cmd no windows) e digite o seguinte comando:

$ npm -v
 4.3.0

Se você está rodando uma versão antiga do npm, então é muito fácil atualizar para a última versão, usando o seguinte comando:

$ sudo npm install npm -g
/usr/bin/npm  -> /usr/lib/node_modules/npm/bin/npm-cli.js
npm@2.7.1 /usr/lib/node_modules/npm   

Para iniciar um novo projeto use o seguinte comando:

$ mkdir teste
$ cd teste
$ npm init -y    

Este comando irá criar um arquivo package.js com a descrição do projeto que terá o mesmo nome que o diretório corrente.

Se agora quisermos instalar o módulo  chamado “Johnny-Five” localmente podemos usar o comando:

$ npm install --save  johnny-five   

Isso irá criar um diretório node\_modules no diretório atual onde o pacote johnny-five será instalado juntamente com todos os pacotes com quem tenha dependências.

A opção --save faz com que o arquivo package.json seja alterado para indicar que o  pacote johnny-five já foi instalado localmente. O comando

$ npm ls    
Irá listar todos os pacotes instalados localmente. O comando

$ npm search mkdir

Verifica se tem algum pacote com nome ou que realize funções similares de manipulação e diretório. O comando

$ npm uninstall johnny-five

Pode ser utilizado para desinstalar o pacote johnny-five junto  com as suas dependências. Na realidade há duas maneiras de instalar as coisas:

• globalmente – isso coloca os módulos em  {prefix}/lib/node_modules, e coloca os arquivos executáveis em  {prefix}/bin, onde {prefix} usualmente é  algo como /usr/local. Isso também instala as páginas de manuais em  {prefix}/share/man, se houver. 

• localmente – Isso instala seu pacote no diretório de trabalho atual  em  ./node_modules, executáveis vão para  ./node_modules/.bin/, e as páginas de manual não são instaladas.

Pacotes e dependências instalados globalmente são armazenados em um diretório do sistema. Em geral, a regra padrão é a seguinte:

• Se você está instalando que você deseja usar apenas no seu programas, usando require ('whatever'), então instale-o localmente, na raiz do seu projeto.

• Se você está instalando alguma coisa que você quer usar no seu shell, ou na linha de comando ou algo assim, instale-o globalmente, de modo que os binários possam ser encontrados no caminho definido pela variável de ambiente PATH.

Vamos tentar instalar o modulo johnny-five utilizando uma instalação global:

$ npm install johnny-five -g

Isso irá produzir um resultado similar mas o módulo será instalado globalmente. A primeira linha da saída amostra a versão do módulo e o lugar onde está sendo instalado.

Node.js

Node.js é uma plataforma para desenvolvimento de aplicações “server-side” baseadas em rede utilizando JavaScript e o V8 JavaScript Engine, ou seja, com o Node.js podemos criar uma variedade de aplicações Web utilizando apenas código em JavaScript. Tem as seguintes características:

• Consistente: as representações de linguagem e dados do servidor/cliente são as mesmas
• Escalável: Arquitetura com uma única thread minimiza o uso de memória e evita custos de mudança de contexto entre threads
• Rápido (em determinadas coisas)

O Node.js é especialmente útil se a E/S for provavelmente o seu gargalo (ou seja, o servidor não está fazendo muita coisa …). Exemplos: entradas em fila, streaming de dados, websockets… De um modo geral, o Node.js é ideal para tarefas leves e em tempo real e uma má escolha para tarefas computacionalmente intensivas. O seu site pode ser encontrado no endereço: http://www.nodejs.org/. Veja o exemplo a seguir:

$ node arquivo.js
$ curl http://0.0.0.0:3000/
> Olá mundo!

Código 

   var http = require('http');
    http.createServer(function(req,res) {
   // Envia o cabeçalho HTTP
   // HTTP Status: 200 : OK
   // Tipo de conteúdo: text/plain  
    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
   // Envia a resposta body como sendo "Olá Mundo!\"  
    res.end('Olá mundo!');
    }).listen(3000);
   // A console vai imprimir a mensagem abaixo 
   console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…');

Conversão de Tipos

Conversão Implícita de Tipos

Em expressões envolvendo valores numéricos e strings com o operador +, os valores numéricos serão convertidos implicitamente para strings. Por exemplo::

X = "A resposta é " + 35; // retorna "A resposta é 35"
Y = 35 + " é a resposta" // retorna "35 é a resposta"

Em expressões envolvendo outros operadores a conversão será feita de acordo com o tipo de dado esperado pelo operador. Exemplo:

X = "37" - 7 // retorna 30
Y = "37" + 7 // retorna 377

Quando dois valores são comparados, números, strings e valores lógicos são comparados por valor:

3 == "3" // Resultado true
1 && true // Resultado true

Usando a conversão implícita podemos usar de um artifício simples para forçar a conversão de número para string e de string para número.

Número para string:

i = 25 ;
s = "" + i ; // s recebe "25" 

String para número:

s = "256" ;
j = s - 0 ; // j recebe 256   

Conversão de Explícita de Tipos

parseInt (str) ou parseInt (str,base): Converte uma string num número inteiro. Str é a cadeia a ser convertida e base é a base em que os números estão codificados. Se a base não for especificada, assume que a string é uma seqüência de algarismos na base decimal (0,1,2,3,4,5,6,7,8,9). Caso encontre algum caractere diferente dos esperados, encerra a conversão:

num = "3A";
x = parseInt(num);    // x recebe 3
y = parseInt(num,16);    // y recebe 58

parseFloat (str): É a função equivalente a parseInt, para converter strings em números reais. Da mesma forma, se encontrar algum caractere não esperado, encerra a conversão.

z = parseFloat("3.15"); // z recebe 3.15

Escrevendo no Documento HTML

A seguir alguns exemplos de como alterar um documento HTML com uso de Javascript.

Exemplo escrever em um documento HTML:

<!DOCTYPE html>
<html>
<body>
    <h2>Minha Primeira Página WEB.</h2>
    <p>Meu primeiro parágrafo.</p>
    <script>
    document.write(5 + 6);
    </script>
</body>
</html>

Exemplo para escrever em um Elemento HTML:

<!DOCTYPE html>
<html>
<body>
    <h2>Minha Primeira Página WEB</h2>
    <p>Meu Primeiro Parágrafo.</p>
    <p id="demo"></p>
    <script>
    document.getElementById("demo").innerHTML = 5 + 6;
    </script>
</body>
</html>

Exemplo para escrever em uma Janela de Alerta:

<!DOCTYPE html>
<html>
<body>
    <h2>Minha Primeira Página WEB</h2>
    <p>Meu primeiro parágrafo.</p>
    <script>
    window.alert(5 + 6);
    </script>
</body>
</html>

Escrevendo na Console

<!DOCTYPE html>
<html>
<body>
    <h2>Ative a depuração com a tecla F12</h2>
    <p>Selecione "Console" no menu de depuração. Então clique executar novamente.</p>
    <script>
    console.log(5 + 6);
    </script>
</body>
</html>  

Inserindo código Javascript

O código Javascript poder ser inserido em diversas posições no código HTML:

• Código Javascript no HEAD

 <!DOCTYPE html>
<html>
<head>
<script>
    function myFunction() {
        document.getElementById("demo").innerHTML = "Parágrafo modificado.";
    }
</script>
</head>
<body>
    <h2>JavaScript no Head</h2>
    <p id="demo">Um paragráfo.</p>
    <button type="button" onclick="myFunction()">Clique Aqui</button>
</body>
</html>

• Código Javascript no BODY

<!DOCTYPE html>
<html>
<body>
    <h2>JavaScript no  Body</h2>
    <p id="demo">Um parágrafo.</p>
    <button type="button" onclick="myFunction()">Clique Aqui.</button>
    <script>
    function myFunction() {
        document.getElementById("demo").innerHTML =
        "Paragrafo Modificado.";
    }
    </script>
</body>
</html>

• Código Javascript a partir de um Arquivo

<!DOCTYPE html>
<html
<body>
    <h2>JavaScript Externo</h2>
    <p id="demo">Um Paragrafo.</p>
    <button type="button" onclick="myFunction()">Clique Aqui</button>
    <p>(myFunction está armazenado em um arquivo externo de nome "myScript.js")</p>
    <script src="myScript.js"></script>
</body>
</html>

Javascript - Introdução

O JavaScript é uma linguagem de programação interpretada de alto nível, dinâmica e não-tipada. Quando aplicada a um documento HTML, pode fornecer interatividade dinâmica em sites. Foi inventada por Brendan Eich, quando trabalhava na Netscape, em 1995. Ele também é co-fundador do projeto Mozilla, da Fundação Mozilla e da Mozilla Corporation.

A linguagem foi padronizada na especificação ECMAScript. Junto com o HTML e o CSS, o JavaScript é uma das três tecnologias principais para a produção de conteúdo para a World Wide Web: a maioria dos sites a utiliza e todo os navegadores modernos a suportam sem o uso de plugins.

O JavaScript em si é bastante compacto, mas muito flexível. Os seus desenvolvedores escreveram uma grande variedade de ferramentas que complementam o núcleo da linguagem JavaScript,permitindo uma ampla quantidade de funcionalidade extra com o mínimo esforço. Essas incluem:

• Interfaces de Programação de Aplicativos (APIs) integradas em navegadores da Web, fornecendo funcionalidades como a criação dinâmica de HTML e configuração de estilos CSS; 

• Captura e manipulação de um fluxo de vídeo da webcam do usuário ou geração de gráficos 3D e amostras de áudio. 

• APIs de terceiros para permitir que os desenvolvedores incorporem funcionalidade em seus sites de outros provedores de conteúdo, como o Twitter ou o Facebook.
• Estruturas e bibliotecas de terceiros que você pode aplicar ao seu HTML para permitir que você construa rapidamente sites e aplicativos. 

O Javascript possui sintaxe similar ao Java, C++; podendo:

• Modificar conteúdo HTML
• Modificar atributos HTML
• Modificar estilos CSS
• Esconder elementos HTML
• Mostrar elementos HTML ocultos
  

Alguns objetos importantes no Javascript são:

• NAVIGATOR: O objeto navegador contém informações sobre o navegador utilizado.
• WINDOW: O objeto WINDOW representa uma janela aberta em um navegador.
• DOCUMENT: Quando um documento HTML é carregado em um navegador da Web, ele se torna um objeto documento. O documento é uma parte do objeto Window e pode ser acessado como window.document
• DATE: O objeto data permite armazenamento básico e recuperação de datas e horários.
• FORM: O objeto formulário do JavaScript é uma propriedade do objeto do documento, que corresponde a um formulário de entrada HTML construído com a etiqueta FORM. Um formulário pode ser enviado chamando o método de submissão (submit) do JavaScript ou clicando no botão enviar do formulário.

O Javascript permite ainda a captura e gerenciamento de eventos, tais como: onClick, onSubmit, onMouseOver, onMouseOut.