WEBVTT

00:00:00.000 --> 00:00:10.000
[MUSICA]

00:00:12.482 --> 00:00:16.137
Oi. Sou Patrick, sou de Sydney
e sou desenvolvedor web.

00:00:16.137 --> 00:00:21.142
Estive pesquisando sobre como usar
JavaScript para controlar dispositivos

00:00:21.142 --> 00:00:24.068
Como Arduinos, Elite Emotion, Ninja Blocks

00:00:24.068 --> 00:00:27.090
e espero ver isso em breve, Pebble Watch.

00:00:28.880 --> 00:00:31.456
Hoje eu irei mostrar sobre

00:00:31.456 --> 00:00:35.860
o básico controlador Arduino
usando Node.

00:00:35.860 --> 00:00:37.650
Nós iremos cobrir a conexão com o

00:00:37.650 --> 00:00:40.072
computador, realizando a comunicação com o

00:00:40.072 --> 00:00:44.699
Arduino, e esperando, bem no final,
fazer uma lâmpada de LED piscar.

00:00:46.020 --> 00:00:48.770
Eu irei aderir ao básico absoluto aqui,
então nós

00:00:48.770 --> 00:00:51.595
não iremos fazer nada
avançado, eu espero.

00:00:51.595 --> 00:00:54.880
nos próximos tutoriais, falarei sobre isso
e será um pouco complicado.

00:00:54.880 --> 00:00:58.610
Mas, para este, nós iremos mostrar
como dar o pontapé inicial.

00:00:58.610 --> 00:01:01.600
Então, vamos lá.

00:01:01.600 --> 00:01:02.575
O que é Arduino?

00:01:02.575 --> 00:01:05.570
muitas pessoas leram ou já ouviram
esta palavra pela internet,

00:01:05.570 --> 00:01:08.790
mencionada, mas nem todos viram
um em ação, então é isto.

00:01:09.810 --> 00:01:12.288
Ela é uma placa micro controlada que

00:01:12.288 --> 00:01:15.130
é open source e que basicamente você pode

00:01:15.130 --> 00:01:19.190
controlar eletrônicos em uma plataforma
que você um pode construir ou consertar.

00:01:19.190 --> 00:01:23.570
As pessoas no Arduino estão loucas para
ter seu código aberto, o que

00:01:23.570 --> 00:01:26.980
significa que vocêpode fazer sua própria
Placa Arduino que realmente querem.

00:01:28.180 --> 00:01:30.880
Este aqui, em particular, é a
Arduino Uno.

00:01:30.880 --> 00:01:33.590
É uma uma variedade, de diferentes modelos

00:01:33.590 --> 00:01:35.750
que pessoas loucas por Arduino tem
realizado.

00:01:37.090 --> 00:01:38.520
Você pode ter muitos componentes

00:01:38.520 --> 00:01:41.900
conectado a ele, também, como a luz LED
lâmpadas, sensores,

00:01:41.900 --> 00:01:44.900
e até mesmo shields, que são tipos de
coisas que você

00:01:44.900 --> 00:01:48.110
coloca no Arduinos para adicionar mais
funcionalidade.

00:01:48.110 --> 00:01:51.340
Este em particular é um MIDI, shield
que tem

00:01:51.340 --> 00:01:54.432
a capacidade de reproduzir sons, como um
Teclado MIDI.

00:01:54.432 --> 00:01:56.610
O que é Node.js?

00:01:56.610 --> 00:01:58.735
Node.js é uma plataforma que usa

00:01:58.735 --> 00:02:01.550
JavaScripts, uma linguagem de script mais
comumente usado

00:02:01.550 --> 00:02:05.710
em páginas da web, desde que você não
faça aplicações de rede, como servidores.

00:02:07.170 --> 00:02:11.780
Hoje o usaremos, para executar um servidor
web que vou falar com nosso Aduino.

00:02:12.900 --> 00:02:16.990
Se você nunca tiver usado Node.js
antes, comece

00:02:16.990 --> 00:02:19.799
indo para Node.js.org, que eu estou
mostrando aqui na tela.

00:02:20.880 --> 00:02:22.570
Clique no botão Instalar e o
tenha instalado

00:02:22.570 --> 00:02:24.170
depois execute-o no seu computador, de
modo que você vai

00:02:24.170 --> 00:02:28.290
seja capaz de continuar e seguir junto com
o código de exemplo que estarei colocando.

00:02:28.290 --> 00:02:30.366
[AUDIO EM BRANCO]

00:02:30.366 --> 00:02:32.410
Então, por que Node.js e Arduinos?

00:02:32.410 --> 00:02:34.160
Por que ligar as duas tecnologias juntas?

00:02:35.380 --> 00:02:38.770
Bem, um dos pontos fortes do JavaScript
é que existem muito poucas APIs

00:02:38.770 --> 00:02:42.360
Além do que, você pode juntar diferentes
formas de fazer as idéias ganharem vida.

00:02:43.910 --> 00:02:45.600
Quer desenvolver um robô que leva

00:02:45.600 --> 00:02:48.060
instruções de seus seguidores no Twitter,
ou uma

00:02:48.060 --> 00:02:49.690
máquina de café que faz um tipo diferente

00:02:49.690 --> 00:02:51.430
de café, dependendo do clima
lá fora?

00:02:52.720 --> 00:02:55.780
Se você quiser adicionar uma ação como um
dispositivo de entrada

00:02:55.780 --> 00:03:01.230
ou alimentação em dados de seu Jawbone
ou produtos de fitness FitBit.

00:03:01.230 --> 00:03:02.760
As possibilidades estarão sempre.

00:03:02.760 --> 00:03:05.380
E JavaScript está se tornando uma ponte
fácil de usar entre as tecnologias,

00:03:05.380 --> 00:03:07.520
porque nós temos um monte de APIs
para acessar.

00:03:09.050 --> 00:03:10.362
E o que é Johnny-Five?

00:03:10.362 --> 00:03:14.250
Johnny-Five, é uma dessas APIs abertas
que faz com que tais JavaScript

00:03:14.250 --> 00:03:17.150
seja uma linguagem valiosa para desenvolver
esse tipo de coisa.

00:03:18.180 --> 00:03:20.188
Ela permite que você controle seu Arduino
utilizando

00:03:20.188 --> 00:03:22.460
funções muito semelhantes às que você
gostaria de usar

00:03:22.460 --> 00:03:24.560
se você tivesse programando-a apenas

00:03:24.560 --> 00:03:28.180
usando a Plataforma Arduino que vem com o
próprio Arduino.

00:03:31.440 --> 00:03:32.980
Estaremos fazendo várias dessas coisas no

00:03:32.980 --> 00:03:36.590
tutorial que ele está explicando aqui,
portanto não se preocupe muito.

00:03:36.590 --> 00:03:37.720
Mas você pode ver, há muitas coisas legais

00:03:37.720 --> 00:03:39.566
que as pessoas já fazem
com isso.

00:03:39.566 --> 00:03:44.970
Nodebot Kinnect sem fio, controlado por
braço de Robô e Running Man LCD.

00:03:44.970 --> 00:03:48.950
Então, você sabe, as possibilidades
ficarão emocionante.

00:03:50.520 --> 00:03:55.290
Ok, para começar vamos precisar conectar
nosso Arduino ao computador.

00:03:56.340 --> 00:04:00.660
Então, vamos fazer isso conectando o nosso
Arduino em uma porta USB.

00:04:00.660 --> 00:04:03.550
Ele serve como a fonte para o
Arduino, e a

00:04:04.610 --> 00:04:07.990
maneira de fazer upload de software para o
nosso Arduino.

00:04:09.020 --> 00:04:11.220
Como você pode ver, uma vez que você
o liga, você

00:04:11.220 --> 00:04:14.700
vai ver que as luzes piscam, o que é um
bom sinal.

00:04:16.430 --> 00:04:18.860
Nesta demostração de hoje, vou estar fazendo um

00:04:18.860 --> 00:04:23.380
exemplo básico de como ligar e desligar
a luz LED.

00:04:23.380 --> 00:04:26.868
Eu já coloquei o jumper onde
deveriam estar.

00:04:26.868 --> 00:04:30.828
Então, se precisa fazer uma pausa, que este seja
capaz de acompanhar, sinta-se livre para

00:04:30.828 --> 00:04:35.320
pause-o agora, e coloque o jumper,
da maneira que eu tenho feito.

00:04:39.510 --> 00:04:41.170
Conectar-se o Arduino é muito
simples.

00:04:42.210 --> 00:04:48.060
Conecte o verde aqui, ao pino 13
no seu Arduino.

00:04:48.060 --> 00:04:51.790
Em seguida, conecte o vermelho no
pino 5 volts

00:04:54.680 --> 00:05:01.130
E, finalmente, conecte o preto,
no pino terra.

00:05:01.130 --> 00:05:02.300
Realmente não se preocupe com as cores,
você pode

00:05:02.300 --> 00:05:06.760
usar fio da cor que você preferir.

00:05:06.760 --> 00:05:12.220
Agora que está tudo feito, estamos prontos
para ir para a parte de software do

00:05:12.220 --> 00:05:17.515
tutorial com o código que tenho que
executar e onde se comunicar com o Arduino.

00:05:19.528 --> 00:05:21.130
O Aplicativo Node é extremamente simples.

00:05:21.130 --> 00:05:25.560
Nós só temos dois arquivos, um arquivo índice
JavaScript e um arquivo pacote JSON.

00:05:27.240 --> 00:05:34.700
Se para você o pacote de arquivos Jason
é novo, o usaremos para dar mais detalhes

00:05:34.700 --> 00:05:38.579
sobre o aplicativo, e outros módulos Node
que são necessários para o aplicativo.

00:05:40.070 --> 00:05:43.286
Pra começar, eu vou passar por cima deste
pacote de

00:05:43.286 --> 00:05:46.120
arquivos JSON, e mostrar-lhe o que
está acontecendo.

00:05:46.120 --> 00:05:49.610
Então, aqui nós temos que o nome de

00:05:49.610 --> 00:05:53.540
nosso aplicativo é, neste caso, Node em
Johnny-Five.

00:05:53.540 --> 00:05:57.930
Pode dar um nome que você preferir,
mas mantenha-o todo com uma só palavra.

00:05:57.930 --> 00:05:59.460
Ele parecem não gostar espaços.

00:05:59.460 --> 00:06:02.420
Vai começar a reclamar de você, assim
fique com apenas uma palavra.

00:06:03.870 --> 00:06:05.900
Nós temos o número de uma versão.

00:06:05.900 --> 00:06:08.020
Mais uma vez, você pode usar qualquer
número de versão

00:06:08.020 --> 00:06:11.660
que você preferir, realmente, para simples
aplicações básicas de teste.

00:06:11.660 --> 00:06:16.240
Vou chamá-lo de 0.0.1, porque este
aplicativo é muito,

00:06:16.240 --> 00:06:19.130
de estágios iniciais e não vai ter
muito o que fazer.

00:06:19.130 --> 00:06:21.280
Então, estou deixando-o em uma versão
mais recente.

00:06:22.520 --> 00:06:25.270
Então a coisa mais importante, que vai
definitivamente evitar

00:06:25.270 --> 00:06:31.250
nossa aplicação trabalhar com Arduinos é
nossa seção de dependência aqui.

00:06:31.250 --> 00:06:34.120
Este é o lugar onde nós dizemos o que outros módulos
precisam de,

00:06:34.120 --> 00:06:37.710
executar em nosso aplicativo para que Node
funcione.

00:06:37.710 --> 00:06:41.800
Então, a gente só precisa de Johnny-Five,
que é o módulo eu estava mostrando antes.

00:06:42.910 --> 00:06:44.380
E esta aqui é a versão.

00:06:44.380 --> 00:06:49.060
Então, neste caso, queremos a versão mais recente
Johnny-Five desse módulo.

00:06:50.550 --> 00:06:53.675
Basicamente, estamos fazendo coisas
simples, tornarem-se apenas o básico

00:06:53.675 --> 00:06:56.970
uma luz LED acesa e apagada, não é
provável que altere.

00:06:56.970 --> 00:07:00.305
Então, vamos supor que, em todas as
versões futura do

00:07:00.305 --> 00:07:04.350
Johnny-Five, vai ser compatível com o que
nós vamos estar fazendo aqui.

00:07:04.350 --> 00:07:08.580
Assim, não precisa ser especificamente,
de qual versão estamos esperando.

00:07:08.580 --> 00:07:12.130
Agora vamos para o índice do arquivo
JavaScript

00:07:15.600 --> 00:07:17.840
Nossos índices do arquivo JavaScript tém todas

00:07:17.840 --> 00:07:20.350
as funcionalidades, apesar do
aplicativo node

00:07:20.350 --> 00:07:24.350
Então, essa é praticamente a nossa nota
do aplicativo


00:07:25.510 --> 00:07:28.980
em 19 linhas, das quais duas são Console
toras.

00:07:28.980 --> 00:07:31.810
Assim, muito, pequeno aplicativo aqui.

00:07:32.940 --> 00:07:33.900
Eu vou passar isso passo a passo e

00:07:33.900 --> 00:07:35.850
explicar o que tudo é e porque é lá.

00:07:37.860 --> 00:07:40.190
Primeiramente, temos nossa variável cinco.

00:07:40.190 --> 00:07:44.030
Nossa variável cinco exige apenas o
Módulo Johnny-Five.

00:07:44.030 --> 00:07:48.600
Mais uma vez, a razão de temos isso
aqui, bem como no arquivo do pacote Jason,

00:07:48.600 --> 00:07:54.570
é que está atribuindo a todos
objetos diferentes e funcionalidade.

00:07:54.570 --> 00:07:57.560
Isso é o que ganhamos com o módulo
Johnny-Five para esta variável cinco,

00:07:57.560 --> 00:08:00.935
para que possamos acessá-lo durante todo
a aplicativo node.

00:08:00.935 --> 00:08:04.740
Um exemplo disso é a nossa próxima
linha aqui, qual é placa.

00:08:04.740 --> 00:08:08.790
Nossa variável a bordo, está criando
uma nova placa de objeto

00:08:08.790 --> 00:08:12.440
que faz parte do módulo Johnny-Five


00:08:12.440 --> 00:08:17.310
Então, nós estamos olhando para o Johnny-Five


00:08:17.310 --> 00:08:19.860
o objeto que temos aqui é necessário, e nós estamos pegando
o objeto da placa.

00:08:21.520 --> 00:08:23.240
O que é toda a parte do módulo Johnny-Five.

00:08:23.240 --> 00:08:24.420
Nós não temos que nos preocuparmos com nada disso.

00:08:24.420 --> 00:08:25.970
Não temos que criar nada disso.

00:08:25.970 --> 00:08:27.680
Tudo está lá

00:08:27.680 --> 00:08:29.350
Agradecemos aos gênios que vieram
antes de nós.

00:08:32.409 --> 00:08:35.140
Em seguida, presentaremos um pouco mais de
variáveis que usaremos mais tarde,

00:08:35.140 --> 00:08:39.929
por isso estamos dizendo a variável LED, e
a variável de estado de alternância.

00:08:39.929 --> 00:08:41.190
Explicarei isso um pouco mais tarde.

00:08:41.190 --> 00:08:45.414
[ÁUDIO EM BRANCO]

00:08:45.414 --> 00:08:48.240
Para começar, olha isso aqui, na verdade.

00:08:48.240 --> 00:08:49.790
Este é um passo importante, porque este é
o que

00:08:49.790 --> 00:08:52.620
virá em primeiro lugar, quando executamos
nosso aplicativo.

00:08:52.620 --> 00:08:54.900
É só um registro do console dizendo que está
esperando o dispositivo para conectar.

00:08:56.000 --> 00:09:01.120
O que isso significa é que, que aparecerá
primeiro, assim que o aplicativo conhecido

00:09:01.120 --> 00:09:04.669
é iniciado apenas para nos informar que o
novo aplicativo está, em execução.

00:09:05.890 --> 00:09:10.070
Mas nós não sabemos ainda se o
nosso Arduino

00:09:10.070 --> 00:09:11.700
conectou-se, e se podemos nos comunicar
com ele.

00:09:13.010 --> 00:09:17.820
O que acontece, é, usando esta transmissão
variável aqui que criamos.

00:09:17.820 --> 00:09:20.600
O que é uma placa-objeto Johnny Five.

00:09:21.810 --> 00:09:24.330
Afirmamos, estar pronto, o que significa
que, quando temos

00:09:24.330 --> 00:09:28.000
o caso pronto excluído do diretório,
significa que.

00:09:28.000 --> 00:09:32.590
A placa é muito rápida, envia qualquer
tipo de comandos e pedidos para ele.

00:09:33.860 --> 00:09:38.030
Nós ativamos esta função aqui, e isso


00:09:39.070 --> 00:09:41.110
começa com uma placa de registo do console
dizendo estar pronto.

00:09:41.110 --> 00:09:44.460
Isso só vamos saber, se formos
acompanhando o console enquanto

00:09:44.460 --> 00:09:47.650
nosso aplicativo node está executando,
e que a placa está pronta para receber.

00:09:49.000 --> 00:09:51.120
Nosso pedido.

00:09:51.120 --> 00:09:54.800
É também uma boa maneira de saber, ou não
se o console está conectado corretamente.

00:09:54.800 --> 00:09:55.520
Você está fazendo uma placa.

00:09:57.380 --> 00:10:01.820
Em seguida, usamos essa variável LED
que nós declarado anteriormente, e

00:10:01.820 --> 00:10:04.882
criamos um novo LED, mais uma vez parte do
módulo Johnny-Five.

00:10:05.910 --> 00:10:10.420
Nós estamos, apenas deixando-o saber que
temos um LED

00:10:10.420 --> 00:10:13.390
No pino 13, que é o que havíamos plugados
anteriormente.

00:10:15.770 --> 00:10:20.985
Então chegamos ao bit JavaScript que
é, estamos definindo um intervalo usando a

00:10:20.985 --> 00:10:24.330
função JavaScript que muitos de vocês
podem ter

00:10:24.330 --> 00:10:26.850
usado se vocês são gurus de JavaScript.

00:10:26.850 --> 00:10:32.440
O intervalo definido significa que estamos
utilizando esta função aqui, alternar LED.

00:10:32.440 --> 00:10:36.530
A cada 200 milissegundos, e você pode
jogar por aí com

00:10:36.530 --> 00:10:39.920
esse número se você preferir mais tarde,
apenas por experiência, e mudar

00:10:39.920 --> 00:10:42.810
a forma como muitas vezes o LED vai
alternar ligado e desligado,

00:10:42.810 --> 00:10:45.550
mas vamos dizer, para executar esta
função a cada 200 milissegundos.

00:10:46.770 --> 00:10:49.000
O que não é bem essa função, a
função aqui tem.

00:10:50.672 --> 00:10:55.180
Três linhas e uma linha de vida que é
apenas para a leitura do usuário.

00:10:55.180 --> 00:10:59.040
Basicamente, usar essa variável aqui, no
estado de alternância,

00:10:59.040 --> 00:11:01.060
que montamos primeiramente para ser falso.

00:11:02.300 --> 00:11:05.840
E em cada alternância de tempo que é executado, o LED vai mudar
o valor do estado de

00:11:05.840 --> 00:11:09.120
alternância de verdadeiro para falso ou de
falso para verdadeiro.

00:11:09.120 --> 00:11:11.709
Então, apenas mudamos o
oposto do que se tratava.

00:11:13.100 --> 00:11:19.890
Se o estado total é verdade, ligamos nosso
LED emissor de luz, se não, o desligamos.

00:11:19.890 --> 00:11:22.700
Então, basicamente, mantemos a alternância
estado liga e desliga, liga e desliga,

00:11:24.120 --> 00:11:27.790
por sua vez, transformando o LED 
liga e desliga e ligado e desligado.

00:11:27.790 --> 00:11:30.390
[AUDIO EM BRANCO]

00:11:30.390 --> 00:11:31.080
Você tem

00:11:32.080 --> 00:11:33.490
Você está seguindo agora este tipo e,

00:11:33.490 --> 00:11:36.060
visualizando a execução da sunção em sua
cabeça.

00:11:36.060 --> 00:11:39.140
Se você vai perceber que não há nada que
desligue

00:11:39.140 --> 00:11:42.360
o LED, por isso vai continuar teoricamente
sempre girando continuamente

00:11:42.360 --> 00:11:45.500
ligando e desligando, ligando e desligando,
até que enfim

00:11:45.500 --> 00:11:48.180
desconecte o Arduino ou que desative esse
aplicativo node.

00:11:48.180 --> 00:11:50.270
E eu vou mostrar-lhe como fazer isso.

00:11:51.580 --> 00:11:55.040
Teoricamente, você poderia incluir algumas
outras funcionalidades, no

00:11:55.040 --> 00:11:59.310
erro para desligar o, Intel, limpando o
Intel se você

00:11:59.310 --> 00:12:02.290
preferir, mas neste tutorial mantem as
coisas simples,

00:12:02.290 --> 00:12:04.110
nós apenas vamos dar o básico que eu estou
mostrando pra vocês.

00:12:04.110 --> 00:12:08.100
Isto é como você pode controlar o Arduino
do node, e

00:12:08.100 --> 00:12:10.930
você pode adicionar tanta funcionalidade
quanto você preferir.

00:12:10.930 --> 00:12:12.010
Além de tudo isso e ter um pouco de diversão.

00:12:14.440 --> 00:12:20.830
Agora que temos esses dois ficheiros
e pronto para rodar o aplicativo Node, nós

00:12:20.830 --> 00:12:29.150
temos que ter certeza que essas dependências que
falamos, estão lá e prontos para ser executado.

00:12:31.110 --> 00:12:34.690
Então, o que eu tenho feito é abrir um
túnel, e eu tenho ido para

00:12:34.690 --> 00:12:39.560
a mesma pasta que nós colocamos os dois
arquivos para provar isso para você.

00:12:39.560 --> 00:12:40.530
Eu só vou te mostrar lá.

00:12:40.530 --> 00:12:44.170
Então, você tem o arquivo JavaScript índice,
e seu arquivo de pacote JSON.

00:12:46.290 --> 00:12:46.790
Então

00:12:48.230 --> 00:12:53.853
Como você costuma executar um aplicativo
node é apenas index.js node.


00:12:53.853 --> 00:12:57.290
E nós vamos tentar executá-lo.

00:12:57.290 --> 00:13:01.610
E o que vemos aqui é o que diz,
não consegue encontrar Módulo Johnny-Five.

00:13:01.610 --> 00:13:02.990
O que é justo.

00:13:02.990 --> 00:13:05.970
Temos dito que no arquivo Índice do JavaScript

00:13:05.970 --> 00:13:10.310
Que não vai ter um módulo node chamado
Johnny-Five e ele foi e procurou por

00:13:10.310 --> 00:13:13.630
ele e não pode encontrar e agora está muito chateado
por nós termos mentido para ele.

00:13:13.630 --> 00:13:16.050
Então, precisamos tê-lo instalado.

00:13:17.540 --> 00:13:21.750
Para instalá-lo, você pode usar um incrível
gerenciador de pacotes chamado MPM.

00:13:23.060 --> 00:13:27.202
MPM apenas executa seu package.json através do
arquivo

00:13:27.202 --> 00:13:29.440
e instala todas as dependências que você
tem listado.

00:13:29.440 --> 00:13:32.150
Se você não tem MPM em sua máquina apenas
fazer uma

00:13:32.150 --> 00:13:35.550
pesquisa rápida no Google para MPM, e instale-o 
no seu computador.

00:13:36.750 --> 00:13:41.179
É um processo muito simples, por isso não vou
citá-lo aqui.

00:13:42.900 --> 00:13:47.460
Então, uma vez que tem o MPM instalado,
você digita no espaço instalar do MPM.

00:13:47.460 --> 00:13:51.460
E, ele vai procurar o arquivo através de
nosso pacote JSON.

00:13:52.790 --> 00:13:54.980
Também tem um bom punhado de avisos,
dizendo que

00:13:54.980 --> 00:13:59.880
não temos alguns daqueles que pudéssemos
ter.

00:13:59.880 --> 00:14:01.620
Descrição eu acho e alguns outros.

00:14:02.700 --> 00:14:05.350
Então, basicamente, é passado e
instalado

00:14:05.350 --> 00:14:08.401
nossos módulos aqui, então temos todos os

00:14:08.401 --> 00:14:11.680
módulos Johnny-cinco, e todas essas outras
coisas

00:14:11.680 --> 00:14:14.790
que considera necessário para executar o
aplicativo.

00:14:16.070 --> 00:14:16.780
Então, agora eu vou

00:14:18.920 --> 00:14:22.580
limpar isto, mas antes de executar o nosso
atual.

00:14:22.580 --> 00:14:26.850
O Aplicativo que vamos precisar para
montar Arduino, de modo

00:14:26.850 --> 00:14:30.760
que seja capaz de receber a comunicação
do nosso aplicaivo Arduino.

00:14:31.980 --> 00:14:36.700
Para obter essa comunicação de trabalho
entre nosso Arduino e o computador,

00:14:36.700 --> 00:14:40.660
só precisa carregar um pequeno código para
nosso Arduino.

00:14:40.660 --> 00:14:44.770
Arduino chama essas partes de esboços de código.

00:14:44.770 --> 00:14:50.018
Que você carrega e, em seguida, instala no
Arduino e, em seguida, o Arduino sabe

00:14:50.018 --> 00:14:55.089
o que precisa fazer, no nosso caso nós não
precisamos do Arduino para fazer muito.

00:14:55.089 --> 00:15:00.480
A maioria da funcionalidade está no Node,
tudo o que precisamos fazer é instalar um

00:15:00.480 --> 00:15:04.030
código para garantir que ele possa entender
como se comunicar com o computador.

00:15:05.960 --> 00:15:10.020
Em primeiro lugar, antes de instalá-lo,
se você não usou o software Arduino

00:15:10.020 --> 00:15:16.410
antes, verifique que a porta serial
está apontando para a porta USB correta.

00:15:16.410 --> 00:15:17.830
Você pode precisar fazer uma tentativa
e errar com

00:15:17.830 --> 00:15:21.180
isto se você não tiver certeza qual
porta USB é a correta.

00:15:21.180 --> 00:15:24.870
Mas no meu caso, foi este modem USB TTY.

00:15:26.990 --> 00:15:28.610
Faça uma tentativa de erro para verificar
quais vão funcionar

00:15:28.610 --> 00:15:33.123
se você está tendo problemas com
o carregamento do código do seu Arduino.

00:15:33.123 --> 00:15:35.625
Definitivamente verifique a configuração.

00:15:35.625 --> 00:15:38.190
Eu também tenho o console criado para ser configurado

00:15:38.190 --> 00:15:42.135
para qualquer placa Arduino
[Inaudível].

00:15:42.135 --> 00:15:43.590
Em seguida carregue o sketch.

00:15:44.910 --> 00:15:47.620
Nós estamos indo para o arquivo, exemplos.

00:15:47.620 --> 00:15:49.145
E então você vai ter isso também em sua

00:15:49.145 --> 00:15:54.980
Fermata, queremos que o padrão Fermata,
esboce aqui, e

00:15:54.980 --> 00:15:58.000
isso como se diz aqui é um protocolo genérico

00:15:58.000 --> 00:16:01.410
para se comunicar com os micro-controladores,
do software no computador.

00:16:03.020 --> 00:16:05.790
Isso é conveniente, porque é exatamente
isso o que queremos fazer.

00:16:05.790 --> 00:16:10.870
Queremos comunicar a partir de suas anotações
do software

00:16:10.870 --> 00:16:14.803
para o nosso micro-controlador, que é o
Arduino.

00:16:14.803 --> 00:16:17.908
Assim, para carregar o nosso Arduino,
Certifique-se que você de

00:16:17.908 --> 00:16:22.320
que ainda esteja conectado ao computador,
e clique em upload.

00:16:22.320 --> 00:16:23.690
Ele irá compilar o sketch.

00:16:24.780 --> 00:16:27.210
Vai enviá-lo para o Arduino.

00:16:28.390 --> 00:16:31.040
E, em poucos segundos deve ser
concluído.

00:16:31.040 --> 00:16:31.620
Aí vamos nós.

00:16:31.620 --> 00:16:33.650
Então, é feito o upload, o que significa
agora você que tem

00:16:33.650 --> 00:16:39.270
o software padrão Fermata ou um
esboço do padrão Fermata.

00:16:39.270 --> 00:16:42.350
No Arduino, o que significa que estamos
prontos agora, para passar para o

00:16:42.350 --> 00:16:46.560
próximo e excitante forma de executar o
código Note e se comunicar com o Arduino.

00:16:48.020 --> 00:16:50.130
Temos a nossa configuração dois arquivos.

00:16:50.130 --> 00:16:55.390
Nosso índice de JavaScript que tem todo o
código para o nosso aplicativo Node.

00:16:55.390 --> 00:16:58.910
Nós instalamos todas as suas dependências,
utilizando MPM.

00:16:58.910 --> 00:17:01.590
Nós também temos nosso Arduino conectado e

00:17:01.590 --> 00:17:06.869
executando o padrão Fermata, código do esboço;
que significa que

00:17:06.869 --> 00:17:10.119
agora está pronto para aceitar todos os comandos
que virá a ele do nosso computador.

00:17:11.319 --> 00:17:14.310
Então, tudo o que resta estar no nosso
terminal

00:17:14.310 --> 00:17:21.099
e digite no Node index.js, e quando
executamos isto,

00:17:23.349 --> 00:17:26.140
nós temos o nosso, à espera do dispositivo
para conectar mensagem, juntamente

00:17:26.140 --> 00:17:31.400
com algumas mensagens que vêm do
Módulo Johnny-Five.

00:17:32.600 --> 00:17:36.269
Encontrado nossa porta serial, que é a

00:17:37.650 --> 00:17:42.890
porta USB que temos o Arduino
conectado.

00:17:42.890 --> 00:17:45.320
O seu um pode ser muito diferente disso.


00:17:45.320 --> 00:17:46.150
Mas realmente não importa.

00:17:46.150 --> 00:17:47.860
A coisa mais importante, é que o nosso
registo de console

00:17:47.860 --> 00:17:51.220
que montamos, que diz, placa pronta,
apareceu.

00:17:51.220 --> 00:17:55.849
E se você ligar a sua luz LED de sua face,
você vai ver que ele não está piscando.

00:17:57.570 --> 00:17:58.060
Que maravilha.

00:17:58.060 --> 00:17:59.346
Isso significa que o código está funcionando.

00:17:59.346 --> 00:18:04.980
Estamos enviando comandos para o 13º
pino, dizendo-lhe

00:18:04.980 --> 00:18:07.450
para que uma luz LED seja ligado e desligado.

00:18:07.450 --> 00:18:10.580
E por isso está ligando e desligando,
e assim por ligar e desligar.

00:18:10.580 --> 00:18:13.630
Assim como nós pedimos pra ele.

00:18:13.630 --> 00:18:16.070
A única questão importante é como você
consegue desligar?

00:18:16.070 --> 00:18:18.650
Como é que você o pára executando 
constantemente?

00:18:18.650 --> 00:18:19.650
Esta anotação do aplicativo.

00:18:21.110 --> 00:18:27.452
Se voltar para o terminal aqui, o que você
tem que fazer é apenas pressione Ctrl C e

00:18:27.452 --> 00:18:34.040
depois Ctrl C novamente e isso vai fechar a
placa e ele vai parar de piscar a luz.

00:18:35.050 --> 00:18:37.550
Se você temporizar corretamente,
a luz será apagada.

00:18:37.550 --> 00:18:40.690
Se o temporizar de forma um pouco diferente,
a luz vai ficar acesa.

00:18:40.690 --> 00:18:42.750
E isso é realmente bom.

00:18:42.750 --> 00:18:43.440
Não é grande coisa.

00:18:43.440 --> 00:18:47.130
Se você quiser desligá-lo completamente,
você pode simplesmente desconectar o

00:18:47.130 --> 00:18:52.750
USB do computador, e ele vai desligar
toda a força do seu Arduino.

00:18:52.750 --> 00:18:53.780
Isso não vai prejudicá-lo de forma alguma.

00:18:53.780 --> 00:18:55.800
É apenas uma maneira rápida de fazê-lo.

00:18:56.920 --> 00:18:59.870
Pare de fazer o que estava fazendo que
você realmente não quer que ele faça.

00:18:59.870 --> 00:19:05.700
E isso, meus amigos, é como você virar um
Diodo emissor de luz ligando e desligando,

00:19:05.700 --> 00:19:11.250
ligando e desligando em um loop infinito usando
Node Johnny-Five e Arduino.

00:19:11.250 --> 00:19:14.510
Se você seguiu junto, agora você deve ter
uma

00:19:14.510 --> 00:19:17.360
luz LED, inclinando-se para o
aplicativo node como correto.

00:19:17.360 --> 00:19:17.860
Bom trabalho

00:19:19.080 --> 00:19:20.500
Isto é o básico

00:19:20.500 --> 00:19:22.090
Há muito mais a fazer a partir daqui.

00:19:22.090 --> 00:19:24.940
Se você tiver alguma dúvida, ou se há
tudo o que

00:19:24.940 --> 00:19:27.300
eu esqueci, não hesite em entrar em contato
comigo.

00:19:27.300 --> 00:19:29.530
Mais uma vez, meu nome é Patrick Catanzariti.

00:19:29.530 --> 00:19:38.110
Estou no Twitter como thatpatrickguy e tenho
também um site Patcat.me.

00:19:38.110 --> 00:19:41.880
Então, não hesite em entrar em contato, se
você fizer algo muito legal com Arduinos

00:19:41.880 --> 00:19:43.260
acompanhado deste tutorial,
definitivamente entre

00:19:43.260 --> 00:19:44.260
em contato, nós adoraríamos vê-lo.

00:19:44.260 --> 00:19:52.719
Obrigado por tomar seu tempo, e eu
espero que você tenha aprendido algo novo.

00:19:52.719 --> 00:19:55.046
Até logo.