Acessando GPIOs da Raspberry Pi 3 por meio de um servidor web embarcado (node.js, express e wiringpi-node)

GPIOs da Raspberry Pi 3

Introdução

 

Quando se desenvolve um dispositivo embarcado, uma necessidade presente na grande maioria dos dispositivos é a implementação de uma interface homem-máquina, ou seja, uma maneira para que o usuário possa interagir com o equipamento. Os componentes mais comuns são o uso de displays e LEDs para apresentar informações ao usuário, e botões ou teclados para o usuário inserir informações ao dispositivo. Existem muitos modelos destes componentes que podem ser utilizados, porém eles apresentam desvantagens, como tamanho e custo. Dependendo da complexidade da interface, por exemplo numa situação com muitas opções de configurações que o usuário deva ser capaz de acessar, uma interface com display pode se tornar ou muito cara, ou muito complicada de se utilizar.

 

Uma maneira de se interagir com dispositivos que tem sido utilizada em uma gama muito grande de dispositivos é por meio de um navegador de internet. Atualmente é possível utilizar-se navegadores de internet em muitos dispositivos diferentes, como computadores, tablets, smartphones, etc. O design de páginas web possibilita a criação de interfaces fáceis de serem utilizadas, bonitas, e capazes de muitos recursos. Por exemplo, imagine como seria configurar um roteador de Wi-Fi residencial sem ser pela sua página web de configuração. São tantas opções de configuração, que a utilização de um display e teclas tornaria o produto praticamente inviável.

 

Este artigo mostra como é possível realizar esta abordagem utilizando uma Raspberry Pi 3. A Raspberry possui todos os recursos necessários para se criar interfaces de controle por meio de páginas web: processador potente, sistema Linux e muitos componentes de software que tornam esta operação relativamente simples de se implementar. Aqui será mostrado um exemplo muito simples, onde será criado um circuito contendo dois LEDs e um botão, e uma página web para interagir com estes elementos. Um dos LEDs poderá ser ligado ou desligado por meio de um botão na página; o outro LED terá seu brilho controlado por um controle deslizante na página; e na página será exibido o estado do botão, se pressionado ou não. Toda a programação será feita em JavaScript, utilizando-se o node.js para executar este script, que realizará as tarefas de servidor de páginas web, comunicação websocket entre o navegador e o servidor, e acionamento dos pinos de GPIO da Raspberry. O vídeo abaixo mostra o circuito e o software em funcionamento.

 

 

Material necessário

 

  • Raspberry Pi 3;
  • Cartão Micro SD (4GB ou maior);
  • Fonte 5V/3A com conector Micro USB.

 

Para realizar as configurações iniciais, é necessário ter à disposição um teclado com conexão USB, e um monitor (ou TV) com entrada HDMI.

 

O acesso à página web será feita por rede. A Raspberry possui duas opções de rede, podendo realizar por cabo e conector RJ-45 ou por Wi-Fi. Assim sendo, é necessário haver disponibilidade de uma destas opções de conectividade para a Raspberry.

 

Para o circuito:

  • 2 LEDs (3mm ou 5mm, de qualquer cor);
  • 2 resistores de 1k;
  • 1 Push-button (de qualquer tipo, do tipo normalmente aberto);
  • 1 protoboard ou placa padrão de montagem;
  • Fios para interligação da Raspberry com o protoboard.

 

Circuito

 

A figura 1 mostra o esquemático do circuito que será acionado. Como pode ser visto, é extremamente simples. Os dois LEDs são acesos colocando-se nível alto nos pinos que estão conectados, e o push-button envia um sinal de nível baixo quando conectado (o processador da Raspberry pode ser configurado para colocar um resistor de pull up nos pinos de I/O).

 

Circuito conectado na Raspberry Pi 3 para criar um servidor web embarcado.
Figura 1: Circuito conectado na Raspberry Pi 3.

 

A figura 2 mostra os nomes dos pinos do conector da Raspberry Pi 3, bem como sua numeração.

 

Pinagem do conector de I/O da Raspberry Pi 3.
Figura 2: Pinagem do conector de I/O da Raspberry Pi 3.

 

O primeiro LED foi conectado na GPIO2 da Raspberry Pi, pino 3. Esta GPIO não foi escolhida por nenhum motivo particular, e qualquer outra GPIO poderia ter sido escolhida, bastando alterar o código para adequar a esta mudança.

 

O segundo LED foi conectado na GPIO18, pino 12. O processador da Raspberry Pi possui vários pinos com capacidade de operar em modo PWM (por hardware), porém destes pinos o único presente no conector é a GPIO18. Desta forma, se for utilizar a função de PWM por hardware, este pino deve ser utilizado.

 

O push-button foi conectado ao GPIO23, pino 16. Para tornar o circuito mais simples, o código que configura e manipula os GPIOs habilita o resistor de pull up interno neste pino. Este GPIO também não foi escolhido por nenhum motivo particular, e qualquer outro GPIO pode ser utilizado também.

 

A figura 3 mostra a forma como os componentes foram montados e conectados numa protoboard.

 

Conexão do circuito utilizando uma protoboard para criar um servidor web embarcado
Figura 3: Conexão do circuito utilizando uma protoboard.

 

Instalação do Sistema

 

O exemplo roda no sistema Raspbian Lite, versão 2017-11-29, que pode ser baixado neste link (349M bytes).

 

Para gravação da imagem, esta página possui instruções, com links para instruções detalhadas usando Windows, Linux ou MacOS.

 

A imagem Raspbian Lite é interessante para sistemas sem interface homem-máquina (também chamados de head-less), porque a imagem possui os recursos mínimos para dar boot e configurar o hardware. O tempo de boot é menor que numa imagem completa, com interface gráfica, e o consumo de RAM também é menor.

 

Após a gravação do sistema no cartão, instale o cartão na Raspberry. Se a conexão de rede da Raspberry será feita por cabo de rede, conecte o cabo. Conecte o teclado USB e o monitor HDMI, conecte a fonte e ligue. Após o sistema terminar o boot (deve demorar uns 20 segundos), será possível realizar o login por meio de nome de usuário e senha. No sistema Raspbian o nome de usuário padrão é “pi” e a senha é “raspberry”.

 

Após o primeiro login, é recomendável realizar as configurações iniciais usando o comando sudo raspi-config. A figura 4 mostra a tela inicial do programa:

 

Programa de configuração do sistema Raspbian.
Figura 4: Programa de configuração do sistema Raspbian.

 

Se for optado por usar conectividade por meio de rede Wi-Fi, deve-se utilizar este programa para realizar a configuração do mesmo, selecionando a opção “Network Options”, “Wi-fi” e inserindo o nome da rede e a senha. Outras opções que podem ser configuradas, são o layout do teclado (caso esteja usando um layout que não seja reconhecido por padrão), acessando a seção “Localization Options”, “Change Keyboard Layout”; e para tornar a programação mais confortável, pode-se habilitar o acesso por SSH, acessando a opção “Interfacing Options”, “SSH”. Com esta opção ativa, é possível o acesso ao terminal e a cópia de arquivos para a Raspberry por meio de algum programa cliente de SSH. Para Windows, um cliente que tenho usado bastante e que possui muitos recursos práticos é o Bitvise SSH Client (gratuito).

 

Como será executado um servidor web na Raspberry, é recomendável configurar a mesma para IP estático (ao invés de IP dinâmico por DHCP). Primeiramente, é necessário escolher um endereço IP dentro da faixa de rede que a Raspberry estará e que não possui nenhum dispositivo utilizado. No meu caso, eu estou utilizando um roteador que distribui internet a partir de uma conexão ADSL para minha rede interna. A rede interna está configurada, no roteador, para criar uma rede com IP 10.1.1.X, sendo que o roteador tem IP 10.1.1.1, e os dispositivos recebem IP a partir de 10.1.1.2 em diante. Como não tenho muitos dispositivos conectados à rede, eu escolhi o IP 10.1.1.185 porque tenho certeza que jamais este IP será utilizado em minha rede. Como cada rede possui configurações diferentes, verifique como está configurada a distribuição de endereços IP em sua rede, e escolha um IP adequado para a Raspberry. Para configurar o Raspbian para IP estático, basta editar o arquivo /etc/dhcpcd.conf, e descomentar as linhas finais do arquivo. O Raspbian Lite vem com o editor de textos nano instalado por default e pode ser utilizado para realizar esta edição. Se por acaso o leitor nunca tenha usado este editor, basta executá-lo com o comando sudo nano /etc/dhcpcd.conf, e após o término da edição do arquivo digite Control+X, pressione y e enter.

 

A primeira linha a ser descomentada é a que diz:

 

 

Para descomentar a linha, remova o caracter ‘#’ no começo da linha. Se a conexão de rede que está sendo utilizada é wi-fi, substitua “eth0” por “wlan0”; por outro lado, se estiver utilizando conexão de rede por cabo, mantenha a opção “eth0”.

 

A linha de baixo, descomente removendo o caracter ‘#’ do início da linha, e substitua o endereço 192.168.0.10 pelo endereço de rede que você escolheu para a Raspberry.

 

A terceira linha pode ser deixada comentada, pois se refere a um endereço estático IPV6, que não utilizaremos neste exemplo.

 

Na quarta linha, substitua o endereço 192.168.0.1 pelo endereço IP do roteador da rede. Na quinta linha, substitua o endereço 192.168.0.1 pelo IP do servidor de DNS primário da rede, que na grande maioria dos casos é o mesmo IP do roteador.

 

Salve o arquivo (com Control+X e selecione y para confirmar), e reinicie a Raspberry com o comando sudo reboot. Logo após o boot, verifique se o IP está configurado corretamente com o comando ifconfig, e verifique se está acessando a internet, por meio de um ping (como por exemplo ping google.com).

 

Se for optado realizar o restante do desenvolvimento acessando-se a Raspberry por meio de SSH, a partir deste momento é possível realizar esta conexão, e a utilização do teclado USB e o monitor conectados à Raspberry é desnecessária.

 

Instalação do node.js

 

O primeiro componente de software que instalaremos é o node.js. De forma muito resumida, o node.js é um interpretador de Javascript que permite executar programas escritos nesta linguagem no lado do servidor. O node.js possui um gerenciador de bibliotecas chamado npm, que oferece uma gama gigantesca de bibliotecas que dão um poder de se criar muitas aplicações de forma muito simples e rápida. Neste exemplo, utilizaremos duas bibliotecas: a “express”, que permite criar um servidor web, e a “wiringpi-node”, que permite o acesso aos GPIOs da Raspberry.nodejs.

 

Antes de instalar um pacote, é recomendável executar o comando sudo apt-get update para atualizar a lista dos repositórios da distribuição. Em seguida instalaremos três pacotes: git-core (que é necessário para o processo de instalação da wiringpi-node), nodejs e npm. Para instalar estes pacotes, digite o comando:

 

 

Inicialização do Projeto

 

Para deixar tudo mais organizado, vamos criar uma pasta e criar todo o projeto dentro dela. Para isso, digite os comandos:

 

 

Agora vamos inicializar o projeto do node.js. Esta etapa não é totalmente necessária, mas é uma prática muito recomendável, se acaso o projeto crescer e se tornar mais complexo. Para realizar a inicialização, digite o comando npm init. Serão apresentadas muitas perguntas, todas elas podem ser respondidas apenas pressionando Enter, que preencherá com o valor padrão. Se porventura decidir modificar algum dos parâmetros, basta preencher com o valor desejado. Este comando criará o arquivo package.json, que receberá informações dos pacotes que serão instalados.

 

Teste do node.js

 

Vamos realizar alguns pequenos testes para verificar que tudo está em ordem. Primeiramente, vamos testar o node.js, com um programa de hello-world bem simples. Para isto, crie um arquivo (que pode ser chamado por exemplo de hello.js) contendo o comando abaixo:

 

 

Execute este comando digitando:

 

 

Se tudo correr bem, será mostrada no console a frase acima.

 

Vamos testar agora o Express. Para isto, vamos criar um página HTML muito simples, que será servida pelo Express por meio da porta 80. Primeiramente, digite o comando:

 

 

Se tudo correr bem, será criada uma pasta chamada node_modules, e dentro desta terá uma pasta chamada express, com muitas outras pastas e arquivos dentro. E no arquivo package.json terá uma entrada para express na seção “dependencies”.

 

Agora, vamos criar o seguinte arquivo HTML, que chamaremos de pagina.html:

 

 

 

Vamos agora criar um arquivo em javascript que será responsável por colocar no ar um servidor web na porta 80, e vai servir o arquivo pagina.html como raiz do servidor.

 

NOTA: O node.js deve ser executado com permissão de root (ou seja, deve ser executado com o comando sudo) para poder servir a porta 80. Esta é uma norma no Linux, para se criar qualquer servidor nas portas 1 até 1023.

 

Vamos criar o arquivo servidor-express.js com o seguinte conteúdo:

 

 

Este código carrega a biblioteca express, e cria um objeto do mesmo que chamamos de app. É então declarado um método responsável por atender as requisições de pedido de página raiz do servidor, que envia para o cliente o arquivo pagina.html. Desta forma, sempre que o usuário solicitar a página sem especificar nenhum outro caminho (ou seja, apenas digitando o endereço IP na barra de endereços do navegador), será fornecido o conteúdo do arquivo pagina.html. É criado mais um método que é executado para qualquer outra requisição de caminho, que manda uma resposta de erro 404 ao navegador do usuário. E por fim, coloca o servidor para escutar a porta 80, que é a porta padrão para o protocolo http.

 

Para executar este código, basta executar o comando:

 

 

E por meio de um navegador acessar esta página preenchendo o IP da Raspberry na barra de endereços.

 

Testando o WebSocket

 

O funcionamento de um servidor web é relativamente simples: o servidor fica aguardando conexões; quando um navegador de internet se conecta ao servidor, ele solicita uma página; o servidor envia esta página, e ao término do envio das informações, a conexão é encerrada. A partir deste momento, o servidor web não tem mais nenhuma informação a respeito do navegador do cliente. Se o servidor necessitar enviar alguma informação a este cliente, ele não tem como, não sabe mais o estado do navegador (se ainda está aberto na página que o servidor enviou, ou mesmo se o navegador ainda está em execução ou o computador ainda está ligado).

 

Existem algumas técnicas para se contornar esta situação, para o caso de o servidor necessitar enviar uma informação ao navegador (que é uma necessidade para este projeto, já que quando o botão que está conectado à Raspberry é pressionado, esta informação deve ser enviada imediatamente ao navegador). Uma das maneiras mais práticas para se implementar esta comunicação é por meio do protocolo websocket. Para isto, o servidor web deve ficar escutando uma porta para conexões por meio deste protocolo. O navegador, após receber a página, se conecta nesta porta, e esta conexão se mantém enquanto o navegador permanecer com a página aberta. O servidor e o navegador sabem quando a conexão foi estabelecida e quando ela foi encerrada. O protocolo websocket aceita o envio de mensagens do tipo string ou então array de valores binários.

 

Existem algumas bibliotecas para o node.js capazes de criar um servidor websocket. Neste projeto, utilizaremos a biblioteca ws. Para instalar, basta digitar o comando:

 

 

E da mesma forma que ocorreu com o express, ele será instalado na pasta node_modules.

 

Para testar o funcionamento do ws, vamos criar um código bem simples que enviará e receberá informações, tanto por parte do servidor como do navegador. A página vai receber um botão, que quando clicado enviará ao servidor uma mensagem. Quando a página receber uma mensagem, vai incluir a mesma em um parágrafo. No lado do servidor, quando este receber uma conexão, vai disparar um timer que enviará a cada meio segundo uma mensagem ao cliente, e ao receber uma mensagem, mostrará a mesma no console. Não é muito útil, mas é adequado para testarmos o funcionamento do protocolo.

 

Primeiramente, vamos modificar o conteúdo do arquivo pagina.html para o seguinte:

 

 

No campo body, incluímos um botão (cujo id é “botao") e um parágrafo (cujo id é “texto”). No campo head, incluímos um código javascript, que possui o método window.onload. Este método é importante, porque ele garante que o código será executado somente após toda a página ter sido carregada pelo navegador. Dentro deste método, o código primeiramente cria uma conexão com o servidor (é importante preencher este campo com o IP que foi configurado para a Raspberry Pi), na porta 31337 (que eu escolhi aleatoriamente). Esta conexão tem código para dois eventos: o primeiro, para quando for estabelecida uma conexão, ele adiciona um event listener (ou seja, um tratamento para um evento), neste caso para o evento de clicar no botão. Este event listener possui uma função anônima, cujo código envia uma string para o servidor. O segundo evento é para quando a página receber uma mensagem do servidor, neste caso o código inclui o conteúdo da mensagem no parágrafo cujo id é “texto”. Eu não coloquei tratamento para o evento de encerramento da conexão porque estou supondo que o servidor não vai encerrar a conexão nunca, mas o correto seria tratar o evento onclose e adicionar um código com o método removeEventListener do botão.

 

No servidor, modificamos o código para ficar assim:

 

 

Neste código é carregada a biblioteca ws, e já é executado o método Server nela (a biblioteca também tem código para rodar como cliente). Logo em seguida é criado o objeto do servidor ws, passando como parâmetro a porta que ficará escutando (note que é o mesmo valor que está no comando de conexão na página html).

 

Em seguida temos o código que trata de eventos referentes ao servidor websocket. Quando este recebe uma conexão, dispara um timer que será executado a cada 500 ms, e executará a função envia_valor, que está logo abaixo no código. Esta função recebe como parâmetro o valor do socket estabelecido, e envia uma string para o cliente. Quando o websocket recebe uma mensagem, este imprime a mensagem no console, e quando a conexão é encerrada (isto ocorre se o navegador for fechado, ou for para outra página), o timer é encerrado, para que o servidor não tente enviar uma mensagem para uma conexão que não existe mais.

 

É importante observar que o código não trata erros nem exceções, uma aplicação mais séria deve levar estas situações em consideração, o código aqui apresentado é meramente didático.

 

Para executar este código, execute o servidor com o comando:

 

 

E reabra a página no navegador, para observar estes recursos em funcionamento.

 

Testando o wiring-pi

 

Agora é hora de mexer um pouco com hardware! Vamos criar um código simples que vai testar o circuito que iremos montar, bem como verificar o funcionamento da biblioteca wiringpi-node.

 

Primeiramente, vamos montar o circuito conforme o esquemático da figura 1. É importante se ter em mente que os pinos do conector de I/O da Raspberry estão conectados diretamente aos pinos do processador da placa, geralmente sem nenhum circuito de proteção no meio. Isso quer dizer que é fácil danificar o processador ao se ligar circuitos neste conector se não for tomado cuidado (e danificar o processador quer dizer perder a placa). Portanto, é muito importante tomar bastante cuidado nesta montagem, e só ligar a placa após ter certeza que tudo está correto.

 

O valor dos resistores vai depender de alguns aspectos. A máxima corrente que se pode obter de um pino de GPIO do processador da Raspberry Pi é um assunto um pouco confuso, já que existem registradores que permitem especificar a corrente máxima, de 2mA a 16mA, porém eu nunca testei o que acontece se este limite for excedido... De qualquer maneira, a corrente necessária para acender um LED depende fortemente de seu modelo. Um valor inicial para se trabalhar é de 1k, que vai fornecer aproximadamente 2mA ao LED. LEDs de 3mm modernos costumam acender bem com esta corrente. Se o brilho ficar fraco, diminuir o valor deste resistor vai aumentar a corrente, mas é preciso ficar atento para não consumir corrente demais e eventualmente danificar o processador.

 

Após montar o circuito e conferir que está tudo certinho, vamos escrever um código somente para testar o circuito. Vamos instalar a biblioteca wiringpi-node com o comando:

 

 

As mensagens de instalação desta biblioteca serão um pouco diferentes, porque esta biblioteca fará download de código-fonte em C do repositório git do wiringPi, compilará estes fontes e disponibilizará métodos em Javascript para acessar as funções destes executáveis, mas o resultado final será exatamente o mesmo, com uma pasta dentro da pasta node_modules chamada wiringpi-node, e uma entrada na seção “dependencies” do arquivo package.json.

 

Para testarmos o circuito e a biblioteca wiringpi-node, vamos criar um arquivo chamado gpio-teste.js e colocar o seguinte código nele:

 

 

O programa inicia carregando a biblioteca wiringpi-node, e configura o acesso à numeração dos pinos como sendo gpio. Desta forma, a numeração no código segue a mesma numeração da figura 2. Em seguida, os pinos que utilizamos no circuito são configurados para saída, entrada ou PWM, conforme sua função. Também é ativado o resistor de pull-up no pino de entrada.

 

Em seguida são declaradas algumas variáveis globais que serão usadas nas funções mais abaixo, e são criados três timers para executar as funções de teste de cada pino. A primeira função, pisca_led(), inverte o estado do pino ligado ao primeiro led, e esta função é executada a cada 250 ms. A segunda função, muda_pwm() aumenta e diminui o valor do PWM, indo de 0 a 1000, em passos de 10 em 10. Por padrão a função pwmWrite aceita valores de 0 a 1024 para mínimo e máximo, respectivamente, mas estes limites podem ser alterados. Esta função é executada a cada 15 ms. Por fim, a terceira função monitora se o botão for pressionado (quando o botão é pressionado é gerado um nível baixo no pino), e a função escreve uma mensagem no console.

 

Para executar o código, basta executar o comando: 

 

 

Com o circuito testado e aprovado, temos todas as peças do quebra-cabeça à mão, podemos agora fazer a aplicação final usado os elementos estudados acima.

 

Implementando o código final

 

Vamos iniciar modificando o código do arquivo pagina.html para o seguinte:

 

 

No campo body do arquivo criamos três elementos, sendo um botão, um controle deslizante e uma div. Na seção head do arquivo, criamos um código CSS para atribuir alguns parâmetros de estilo aos elementos presentes no body, como tamanho, cor, etc.

 

O código Javascript guarda muitas semelhanças em relação ao código feito para testar o websocket, com algumas diferenças importantes. Primeiramente, o botão possui dois listeners, sendo um para quando o botão é pressionado, e outro para quando é solto. Desta forma, o servidor receberá uma mensagem quando o botão for pressionado (para fazer o LED acender), e outro quando o botão for solto (para fazer o LED apagar). Eu implementei desta forma porque achei que ficaria legal 🙂

 

Por fim, é criado um terceiro listener, que é executado sempre que o controle deslizante for alterado.

 

A forma como as informações são enviadas para o servidor são diferentes neste código. Como já foi dito anteriormente, o websocket permite enviar strings e arrays de valores binários. Em Javascript, uma forma muito prática de se armazenar valores de elementos distintos é por meio de objetos em notação JSON, porém, o websocket não permite o envio de objetos JSON. Para se contornar esta limitação, foi utilizado o método JSON.stringify. Este método recebe um objeto JSON, converte para uma string e envia ao servidor.

 

O método que é executado quando o código recebe uma mensagem via websocket faz o inverso: por meio do método JSON.parse ele converte a string recebida em um objeto JSON. O código em seguida verifica se no objeto contém um parâmetro chamado btn: se houver, troca a cor de fundo da div; da mesma forma, verifica se há um parâmetro chamado pwm: se houver, muda a posição do cursor do controle deslizante.

 

O código do arquivo servidor-express.js deve ser alterado para o seguinte:

 

 

A parte inicial do código faz o carregamento das bibliotecas express, ws e wiringpi-node conforme os exemplos anteriores. Em seguida, é feita configuração dos pinos de GPIO, da mesma forma como foi feito no terceiro exemplo. No final do arquivo, são definidos os métodos do express para funcionar como servidor na porta 80, exatamente como no primeiro exemplo.

 

Quando o servidor websocket recebe uma conexão, faz uma leitura do estado do botão e imediatamente envia uma mensagem contendo o estado do botão e o valor do PWM, criando um objeto JSON com estes parâmetros e convertendo em string por meio do método JSON.stringify.

 

Em seguida, é criado um timer que fica verificando a cada 25 ms se o botão teve seu estado modificado, e caso verifique que isto ocorreu, envia esta informação ao cliente por meio da conexão websocket. Por fim, o método de tratamento de mensagens recebidas verifica o parâmetro JSON recebido, e atua o primeiro LED para acender ou apagar, ou atua o segundo LED alterando o valor do PWM.

 

Para executar este código, basta executar:

 

 

E acessar o servidor por meio de algum navegador. O resultado será o mesmo do vídeo no início deste artigo.

 

Conclusão

 

Este artigo demonstrou como pode ser simples a implementação de uma interface homem-máquina utilizando uma página web capaz de interagir com as I/Os da Raspberry. A biblioteca wiringpi-node possui recursos para acesso, além de GPIO e PWM, para porta serial, SPI, I2C e interrupções. Desta forma, é possível a criação e interfaceamento com uma gama muito vasta de dispositivos eletrônicos, inclusive podendo-se conectar um microcontrolador (para executar funções mais elementares de controle no hardware) se comunicando com a Raspberry via SPI ou serial, e esta fornecendo a interface homem-máquina via web com o usuário.

 

A página deste exemplo, além de muito simples (e possuir um design horroroso), não possui nenhum controle de acesso. Porém existe muita documentação em livros, tutoriais e vídeo-aulas de como criar aplicações mais complexas e interessantes. Pode-se, por exemplo, implementar uma página de controle de acesso (por meio de usuário e senha), acessar logs (por exemplo, dos últimos valores lidos de sensores), apresentar gráficos, etc.

 

Na parte do servidor, também não foi estabelecido nenhum controle para a situação de mais de um navegador acessar o servidor simultaneamente, o que provoca efeitos de perda de conexão. Pode-se decidir que o servidor não aceite mais de uma conexão ao mesmo tempo, ou então pode-se fazer uma negociação de portas para possibilitar múltiplas conexões, etc. E também não há tratamento de nenhuma exceção, se isto ocorrer, o node.js encerra com uma mensagem de erro. Para uma implementação mais robusta, estes cuidados devem ser tomados.

 

Saiba mais

 

O Hardware da Raspberry Pi 3

Usando Node.js e o framework Express para acessar os pinos de GPIO da Colibri VF61 via Web

Usando a porta serial em Node.js

 

Referências

 

Raspberry Pi 2 & 3 Pin Mappings

Bitvise SSH Client: Free SSH file transfer, terminal and tunneling

Node.js

npm package manager

NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Christian Schultz
Engenheiro Eletricista com ênfase em Sistemas Embarcados, formado pela UFPR, atuo com eletrônica e projetos eletrônicos desde o século passado.

6
Deixe um comentário

avatar
 
3 Comment threads
3 Thread replies
4 Followers
 
Most reacted comment
Hottest comment thread
5 Comment authors
Gerson luisChristian SchultzMurilo RufinoNelson SpodeChristian Schultz Recent comment authors
  Notificações  
recentes antigos mais votados
Notificar
Murilo Rufino
Visitante
Murilo Rufino

Boa noite Christian
fiz os passos descritos neste artigo e funcionou corretamente.
Mas gostaria de saber se tem alguma forma de colocar esse script "servidor-express.js" executar automaticamente com o Boot da Raspberry e em segundo plano.

Christian Schultz
Visitante
Christian Schultz

Olá Murilo, tem duas maneiras. A mais simples é editar o arquivo /etc/rc.local e adicionar uma linha que executa este comando (o script rc.local é executado sempre que o sistema raspbian é iniciado), ou então criando um Unit para o systemD. Este vídeo explica certinho como criar um Unit no systemD no Raspbian: https://www.youtube.com/watch?v=n8pe_2oxe8Q&t=2s

Nelson Spode
Visitante
Nelson Spode

Olá Christian, parabenizo pelo excelente artigo. Muito didático e com conteúdo limpo e muito bem explicado. Certamente milhares de brasileiros se beneficiarão deste conteúdo por ser escrito em nossa língua mãe.

JoacirAndrade
Visitante
JoacirAndrade

boa noite,
segui os passos indicados mas quando chegou na parte de testar o ws tive problemas. Segue abaixo o erro reportado:

[email protected]_RPi1:~/gpio-server $ sudo nodejs servidor-express.js

/home/pi/gpio-server/node_modules/ws/index.js:3
const WebSocket = require('./lib/websocket');
^^^^^
SyntaxError: Use of const in strict mode.
at Module._compile (module.js:439:25)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Module.require (module.js:364:17)
at require (module.js:380:17)
at Object. (/home/pi/gpio-server/servidor-express.js:4:16)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
[email protected]_RPi1:~/gpio-server $

O que aconteceu?

Atenciosamente

Joacir Andrade

Gerson luis
Visitante
Gerson luis

Ola Christian , tb tive o mesmo problema e como vi sua mensagem, eu peguei e atualizei pra ultima versao o node, mas mesmo assim da erro