Na realidade há um apanhado de coisas que precisam ser colocadas em ordem para poder imprimir diretamente sobre um porto serial ou paralelo desde um aplicativo ElectronJS e em especifico sobre raspberry.

No nosso caso, estamos tentando imprimir sobre uma Tanca TP-650 (Uma Epson remarcada, nada mais) Então todo mundo que alguma vez programou em Clipper, C, Pascal, Basic e precisou imprimir em um porto paralelo e/ou serial, está de parabéns por terem resistido até agora. Tudo aquilo que aprenderam lá trás na pre-história vai ser tremendamente útil e correrão com vantagem e com leveza…até com lágrimas de satisfação nos olhos.

A parte mole do lance

Bom, a primeira coisa é espetar a impressora e ver o que acontece. Lembre que estamos com um Raspberry basicão e se precisamos de alguma coisa mais, iremos fazendo. E – para os desavisados de plantão – sendo que Raspbian é filhote de Debian, o que se aplique a ele quase com certeza se aplica ao paizão.

Dizemos que esta é a parte mole porque não há necessidade de drivers já que vamos imprimir direto no porto…. sim, é uma ESC/POS, então vamos mandar código binário direto para ela.

Após espetar a impressora, rode dmesg  para ver em que pé estamos.

A primeira coisa é definir onde a impressora está conectada. No caso ela aparece como uma ‘lp’ (line-printer) numa porta usb … na realidade é a primeira impressora de linhas conectada via usb (usblp0)

Traduzido, haverá um arquivo virtual (tudo é um arquivo em Linux) na /dev/usb chamado lp0. Ou, dito de uma só vez: /dev/usb/lp0

Imprimir nesse porto deveria ser uma coisa muito simples:

echo "Meu primeiro teste" > /dev/usb/lp0

Mas, em lugar de uma bela linha dizendo “Meu primeiro teste” na impressora temos uma mensagem de erro. Isso é porque não temos direito de acessar o porto diretamente.

stat /dev/usb/lp0

Se observamos a saída do stat o proprietário é root e o grupo é lp. Você faz parte do grupo lp? quase com certeza não. Então devemos adicionar você (no nosso caso o usuário chamado pi) ao grupo chamado lp.

sudo usermod -a -G lp pi

Agora, precisa você fazer logoff e logon para que esses direitos se tornem efetivos e só depois testar de novo fazer o echo diretamente na porta lp0

Obvio que se não é lp o grupo ou lp0 o local de sua impressora, você precisa adaptar isso tudo que estamos dizendo.

Para verificar quais os grupos ao que o usuário pi pertence, você pode fazer assim:

id pi

A lança da parte mole

A parte mole é o software, mas ela precisa de uma lança e eu precisava de um trocadilho.

No nosso aplicativo quiosque, vamos instalar uma livraria que gerencia estas impressoras ESC/POS

npm install node-thermal-printer

Isso feito, vamos testar ela tentando imprimir direto desde o javascript assim que o sistema abre. (Nada mais inútil que uma etiqueta no inicio do software mas se trata apenas de um teste e são as 17:16 e estou nisto dede as 05:00 então imagina minha jucundidade)

Ai no index.html temos a carga de um .js qualquer… por exemplo “teste.js” Ele vai conter o seguinte:

var ESC=String.fromCharCode(0x1B), 
    GS=String.fromCharCode(0x1d),
    NUL=String.fromCharCode(0x00),
    SOH=String.fromCharCode(0x01),
    STX=String.fromCharCode(0x02),
    ETX=String.fromCharCode(0x03),
    EOT=String.fromCharCode(0x04),
    BOLD_START = ESC+"E"+SOH,
    BOLD_END   = ESC+"E"+NUL,
    BLANK_LINE = ESC+"d"+SOH,
    CENTER     = ESC+"a"+SOH,
    BC_CODE39  = GS+"k"+EOT,
    CUT_PAPER  = GS+"VA"+ETX;
var command=ESC+"@"+BOLD_START+"Teste do Esteban"+BOLD_END+BLANK_LINE+"Minha Coisa!!!\n"+BC_CODE39+"606"+NUL+BLANK_LINE+"606\n"+CUT_PAPER;

var printer = require("node-thermal-printer");
printer.init({
  type: 'epson',
  characterSet: 'raw',
  interface: '/dev/usb/lp0'
});

printer.print(command);
printer.execute(function(err){
    if (err) {
      console.error("Deu crepe", err);
    } else {
     console.log("Impressão realizada");
    }
  });

Com isso feito, ele imprime uma etiqueta no inicio do programa

Mas, o bom é ver a tela de depuração do ElectronJS (leia-se chrome) para poder acompanhar, depurar, testar o que está sendo feito; então antes de soltar a versão, modificamos o main.js para abrir a tela de depuração assim:

mainWindow.webContents.openDevTools()

Isto feito, temos uma linda etiqueta como a seguir

Obvio que está desalinhada, desajeitada e que falta um seis no número padrão de testes, mas quem está ligando para isso agora?

O que segue agora é padrão, ou seja, implementar o webService de controle, a tela de configuração e a impressão usando os botões na tela.

A ponta de lança está construída.

Temos um Raspberry e um desafio de fazer um sistema de senhas de atendimento que rode em qualquer plataforma.

Então instalamos node, um boilerplate do electron, uma interface gráfica e o YeAPF para fornecer um webservice acessível por um consumidor qualquer com uma tela tipo quiosque.

Instalando as coisas.

Estamos partindo do suposto que seu raspbian está já configurado com o mínimo de recursos possíveis (leia-se: sem GUI nem nada extra)

Instalando node

Primeiro usamos ssh para entrar no Raspberry e poder instalar de lá o node assim:

cd ~/
mkdir tmp-node
cd tmp-node
wget https://nodejs.org/dist/v8.2.1/node-v8.2.1-linux-armv7l.tar.xz
tar xfv node-v8.2.1-linux-armv7l.tar.xz
cd node-v8.2.1-linux-armv7l
sudo cp -R * /usr/local/

Instalando electron

Depois usando o mesmo terminal, instalamos o ElectronJS assim:

sudo npm install -g electron --unsafe-perm=true --allow-root

Instalando a interface gráfica

Como bom filho de peixe, esta truta aqui não tem interface gráfica. Então tivemos que instalar uma interface gráfica para alguém consiga enxergar alguma coisa e não apenas imaginar.

sudo apt-get update -y
sudo apt-get install --no-install-recommends -y xserver-xorg xinit
sudo apt-get install -y xfce4 xfce4-terminal
#vamos precisar desta livraria
sudo apt install libgconf2-4

Brincando com ElectronJS

Agora podemos clonar o electron-quick-start e começar a brincar com ele (Se está em MAC, Linux, Windows é a mesma coisa).

Só que isto deve ser feito do console do próprio RaspBerry para evitar uma alma angustiada.

cd ˜/
git clone https://github.com/electron/electron-quick-start quiosque
cd quiosque
npm install
export DISPLAY=:0
npm start

Feito isso, queremos que nosso aplicativo rode em modo Quiosque (se é que essa é a melhor tradução de

Kiosk) para tanto, vamos modificar o main.js

Então na função createWindow() vamos a acrescentar a seguinte linha logo após do mainWindow.loadFile(‘index.html’)

echo "Meu primeiro teste" > /dev/usb/lp0

echo 'Meu primeiro Teste' > /dev/usb/lp0

stat /dev/usb/lp1

Com isso, o aplicativo deve passar a rodar em tela cheia.

Configurando a inicialização do dispositivo

Configurando o Raspbian para fazer login automático

Agora precisamos modificar o /etc/lightdm/lightdm.conf para que o Raspberry não pare na tela de login. Ele deve ficar assim:

[Seat:*]
pam-service=lightdm
pam-autologin-service=lightdm-autologin
autologin-user=pi
autologin-user-timeout=0
session-wrapper=/etc/X11/Xsession
greeter-session=lightdm-greeter

No meu caso o usuário é pi mesmo, por isso que está pi.

Faça um reboot para ver se está tudo ok

Caso não funcione, pode ser que precise adicionar o usuário ao auto-login assim:

groupadd -r autologin
gpasswd -a pi autologin

Rodando nosso programa no login

Vamos precisar de um pequeno programa que inicie nosso programa. Isto facilitará as coisas para monitorar o programa por exemplo, ou para rodarmos outras coisas que não são do npm.

O chamaremos quiosque.sh e o colocaremos na pasta principal do usuário pi. Ou seja, ~pi/quiosque.sh (ou /home/pi/quiosque.sh que é a mesma coisa) com o seguinte conteúdo:

#!/bin/bash

logger Iniciando Quiosque
cd ~pi/quiosque && npm start
logger Finalizando Quiosque

Com isso, toda vez que chamar-mos ~pi/quiosque.sh, ele vai indicar que entrou em funcionamento e assim que ele finalizar (normalmente ou não) também o fará.

Podemos ver isso no /var/log/messages usando o tail

Criamos um arquivo em /home/pi/Desktop/ chamado quiosque.desktop com o seguinte conteúdo:

[Desktop Entry]
Name=meu-aplicativo
Comment=Quiosque
Exec=cd ~/quiosque && npm start
TryExec=cd ~/quiosque && npm start
Type=Application

E mudamos os direitos dele para poder ser executado

chmod +x /home/pi/Desktop/quiosque.desktop

Com isso, poderemos clicar duas vezes no atalho que deve ter aparecido no Desktop.

Finalmente, fazemos com que esse arquivo desktop seja chamado toda vez que fizermos login:

cd ~/.config/autostart/
ln -s ~/Desktop/quiosque.desktop .

Com isso, ao reiniciar o raspberry, o aplicativo deve aparecer em tela cheia.

Obvio que qualquer purista vai dizer que precisamos substituir o desktop. Mas isso já é farinha de outro saco. Para desenvolvimento, teste e demonstração está muito mais do que bom

Nosso desenvolvimento seguirá neste post mostrando como acessar o hardware diretamente