Hoje em dia, a maioria dos hotéis e restaurantes aceita pedidos de comida online. Muitos hotéis e restaurantes facilitam a pré-encomenda ou até prestam serviços de entrega nas áreas locais. Neste projeto, um sistema de gerenciamento de pedidos de hotel é projetado onde um cliente pode pré-encomendar alimentos usando um aplicativo móvel e um servidor baseado em Raspberry Pi gerencia o atendimento de itens de menu e pedidos de reserva. Em cada reserva, o cliente é informado do horário em que seu pedido estará pronto, para que possa chegar no horário especificado e retirar seu pedido.
Este Hotel Order Management System é baseado na Internet das Coisas e usa o protocolo MQTT para comunicação entre o aplicativo móvel e o servidor Raspberry Pi. O Raspberry Pi como servidor é instalado no Hotel e permanece conectado à internet por um ponto de acesso Wi-Fi. Para esse propósito, é usado o Raspberry Pi 3, que vem equipado com modem Wi-Fi integrado. O Raspberry Pi é conectado a um monitor de exibição onde a equipe do hotel pode visualizar os pedidos recebidos.
O Raspberry Pi e o aplicativo móvel se comunicam por meio de um corretor MQTT. O corretor MQTT usado neste projeto é o HiveMQ. O aplicativo móvel assina um tópico 'FromServer' enquanto publica em um tópico 'ToServer'. O servidor Raspberry Pi como outro cliente MQTT se inscreve no tópico 'ToServer' e publica no tópico 'FromServer'. A carga útil no tópico 'ToServer' é o item de menu selecionado pelo usuário no aplicativo móvel. Quando o servidor Raspberry Pi recebe um pedido de um item de menu do aplicativo móvel no tópico – ‘ToServer’, ele envia o número do pedido e o horário para retirada como carga útil no tópico – ‘FromServer’.
No Raspberry Pi, a comunicação IoT com o corretor HiveMQ é gerenciada por um script python, enquanto o aplicativo móvel usa a biblioteca cliente paho-MQTT para gerenciar a comunicação IoT com o corretor HiveMQ. O aplicativo móvel é desenvolvido em Android Studio. O aplicativo possui uma única atividade onde o cliente pode selecionar um item do menu para fazer o pedido.
Componentes necessários –
1) Framboesa Pi 3
2) Qualquer smartphone
Software necessário –
1) SO Raspbian
2) Leafpad/GNU Nano/Python 3 IDLE (para escrever script python)
3) Android Studio (para desenvolvimento de aplicativos Android)
4) Biblioteca cliente Paho MQTT – serviço Android (para importação no aplicativo Android)
Diagrama de bloco –
Figura 1: Visão geral do servidor Raspberry Pi e do sistema de gerenciamento de pedidos de hotéis IoT baseado em MQTT
Conexões de Circuito –
Neste projeto, um Raspberry Pi e um Smartphone são usados como dispositivos IoT. Ambos atuam como clientes MQTT na rede IoT, enquanto o HiveMQ serve como o corretor MQTT. O Raspberry Pi é conectado a um monitor de exibição onde ele mostra os pedidos recebidos por meio do aplicativo móvel. O Raspberry Pi é configurado para executar um script python na inicialização. Este script python consegue receber pedidos como um assinante MQTT, exibir pedidos recebidos junto com o número do cliente, tempo para retirada do pedido e id do pedido no monitor de exibição e enviar de volta o número do pedido e o tempo para o pedido pronto como publicador MQTT para o aplicativo móvel. O script python foi desenvolvido em Python 2.7.
Figura 2: Logotipo e imagem do Raspberry Pi e MQTT
O smartphone é instalado com um aplicativo a partir do qual um pedido pode ser feito. O aplicativo foi desenvolvido usando Android Studio. O aplicativo móvel está usando a biblioteca cliente paho-MQTT para comunicação IoT, como o python no lado do gerenciamento.
Como funciona o circuito –
O servidor Raspberry pi está conectado ao corretor MQTT por meio do roteador sem fio do hotel. O App é então conectado à mesma corretora através da conexão de internet do celular.
O servidor Raspberry pi está executando um script python que se conecta ao corretor MQTT usando a biblioteca paho-MQTT. O script contém o item de menu. Agora quando o aplicativo móvel está conectado ao corretor ele envia uma string de sinal em um tópico “ToServer”, o servidor Raspberry pi está inscrito no mesmo tópico e recebe esse sinal. Agora o servidor responde com os itens de menu do tópico “FromServer” que está inscrito no App. A partir desses itens de menu quando um cliente pede algo ele vai para o Servidor e se os dados forem válidos ele envia ao usuário o tempo em que seu pedido estará pronto.
Guia de programação –
Neste projeto, são desenvolvidos um aplicativo móvel para smartphone e um script python para rodar no Raspberry Pi. O aplicativo móvel desenvolvido aqui é um aplicativo Android. Para desenvolver aplicativos móveis, primeiro baixe e instale o Android Studio. Abra o Android Studio e crie um novo projeto. Nomeie o projeto – Hotel Order System e forneça o nome de qualquer empresa. O nome da empresa também pode ser o nome do desenvolvedor. Clique em próximo. Na tela Target Android Devices, mantenha os valores padrão e clique em Next. Selecione o SDK mínimo suportado pelo smartphone no caso. Na tela Adicionar uma atividade ao celular, selecione Atividade vazia e clique em Avançar. Na tela Configurar Atividade, mantenha os valores padrão e clique em Concluir. Abra a janela do projeto navegando até Exibir > Janelas de ferramentas > Projeto, se não estiver aberta, selecione Android View. Aqui pode ser visto que o projeto contém os seguintes arquivos principais –
app > java > com.example.themenu > MainActivity : Esta é a atividade principal (o ponto de entrada do aplicativo). Quando o aplicativo é compilado e executado, o sistema inicia uma instância desta atividade e carrega seu layout.
app > res > layout > Activity_main.xml: Este arquivo XML define o layout da UI da atividade.
app > manifestos > AndroidManifest.xml: O arquivo de manifesto descreve as características fundamentais do aplicativo e define cada um de seus componentes.
Gradle Scripts > build.gradle: Serão dois arquivos com este nome: um para o projeto e outro para o módulo “app”. Cada módulo possui seu próprio arquivo build.gradle, mas este projeto atualmente possui apenas um módulo.
Em Navegue até a guia Activity_main.xml se ela ainda não estiver aberta. Certifique-se de que a guia Design esteja aberta na exibição Activity_main.xml. Em res -> layout -> atividade_main.xml, adicione os elementos de layout que incluem dois widgets textview, um scrollview, um listview, dois edittext e um botão. Há uma única atividade neste aplicativo.
Baixe a biblioteca do cliente Paho-MQTT – Android Services. Em seguida, abra app > manifests > AndroidManifest.xml e adicione permissões e cliente Paho-MQTT como um serviço Android.
Em seguida, abra MainActivity.java e anote o código java do aplicativo. O código java tem os seguintes destaques principais –
1. A biblioteca e suas funções são utilizadas para assinatura no tópico “FromServer” e publicação no tópico “ToServer”.
String estática MQTTHOST = “tcp://broker.hivemq.com:1883”;
String topicStr = “ToServer”;
String topicSub = “FromServer”;
2. O aplicativo recebe os itens de menu do servidor
3. Em seguida, esses itens de menu são exibidos na tela do aplicativo
menuArray.add(new String(message.getPayload ));
ArrayAdapter adaptador = new ArrayAdapter(MainActivity.this, android.R.layout.simple_list_item_1, menuArray);
4. Agora no aplicativo existem dois campos que recebem entrada de texto e essas entradas estão sendo enviadas ao servidor.
msgToserver = (EditText)findViewById(R.id.orderno);
mensagem = “ooo”+ msgToserver.getText .toString ;
cliente.publicar(tópico, mensagem.getBytes , 0, falso);
5. O servidor responde de acordo com a consulta
Para obter mais detalhes sobre como usar a biblioteca cliente MQTT – Paho Android Service para comunicação com o corretor HiveMQ, confira o seguinte tutorial –
Enciclopédia da biblioteca do cliente MQTT – Serviço Paho Android
O Raspberry Pi funciona como outro cliente MQTT. Ele executa um script python que funciona como utilitário de gerenciamento de pedidos de hotéis. Primeiro de tudo, o Raspberry Pi precisa ser carregado com um sistema operacional. Aqui está instalado o sistema operacional oficial do Raspberry Pi – Linux Raspbian. Durante a instalação do sistema operacional, o Raspberry Pi deve ser conectado a um monitor usando um cabo HDMI e um teclado e mouse através de portas USB.
Para instalar o sistema operacional Raspbian no cartão MicroSD, primeiro baixe a imagem mais recente do sistema operacional Raspbian no site Raspberry Pi no link a seguir –
Sistema Operacional Raspbian
Copie a imagem do sistema operacional Raspbian mais recente no cartão MicroSD. Se o cartão MicroSD usado tiver 32 GB ou menos, ele deverá ser formatado para FAT32 (sistema de arquivos) antes de copiar a imagem ou se o cartão MicroSD tiver mais de 32 GB, ele deverá ser formatado para exFAT antes de copiar a imagem. Extraia o Zip do sistema operacional e copie-o para o cartão MicroSD. A imagem pode ser gravada no cartão conectando-o a um laptop ou PC usando um leitor de cartão MicroSD. Após copiar a imagem extraída, insira o cartão no slot MicroSD conforme mostrado abaixo –
Fig. 3: Imagem típica do slot para cartão MicroSD Raspberry Pi 3
Conecte o Raspberry Pi a um monitor usando um cabo HDMI, um teclado e um mouse. Ligue a placa conectando-a a um adaptador de energia. O LED vermelho na placa começará a piscar e o sistema operacional começará a inicializar a partir do cartão MicroSD. O processo de inicialização será exibido no monitor e assim que a inicialização for concluída, o LED verde acenderá no Raspberry Pi. Após instalar com sucesso o Raspbian OS no Raspberry Pi, é recomendado realizar a atualização do software. Isso pode ser feito executando os seguintes comandos do Linux no Terminal Linux –
$ sudo apt-get atualização
$ sudo apt-get upgrade
Depois de instalar o Raspbian, é hora de escrever e executar os scripts python no Raspbian. Um script python pode ser escrito em Raspbian usando um editor de texto como Leafpad ou GNU Nano. O script python também pode ser escrito usando o IDE python padrão, como Python 2 IDLE ou Python 3 IDLE. Abra o Python 3 IDLE navegando através de Menu -> Programação -> Python 3 IDLE. Uma janela chamada Python 3.4.2 Shell será aberta. Escreva os scripts python e salve-os em um diretório.
O script python escrito para este projeto deve ser executado na inicialização quando o Pi 3 estiver ligado. O script executa um loop infinito para que nunca termine. Existem alguns métodos pelos quais o Raspberry Pi pode ser configurado para executar um script python na inicialização. Qualquer um dos seguintes métodos pode ser usado –
1) Editando rc.local –
Os comandos podem ser adicionados ao arquivo /etc/rc.local para executar um programa ou comando quando o Raspberry Pi inicializar. Isso é especialmente útil se o Pi precisar ser conectado à energia sem cabeça e executar um programa sem configuração ou inicialização manual. O arquivo deve ser editado com root executando os seguintes comandos no Terminal Linux –
sudo nano /etc/rc.local
Agora adicione comandos para executar o script python usando o caminho completo do arquivo e adicione um e comercial no final do comando para que o script seja executado em um processo separado e a inicialização possa continuar. O seguinte comando deve ser adicionado onde o script python é salvo como menu.py –
sudo python /home/pi/menu.py &
saída 0
O comando deve ser adicionado logo antes da linha exit 0 no arquivo rc.local.
2) Editando .bashrc –
O .bashrc é um arquivo oculto na pasta home que contém opções de configuração do usuário. Abra o arquivo .bshrc executando os seguintes comandos no terminal Linux –
sudo nano /home/pi/.bashrc
Adicione as seguintes linhas após a última linha do arquivo –
echo Executando na inicialização
sudo python /home/pi/menu.py
3) Adicionando script ao diretório init.d –
O diretório init.d contém os scripts que são iniciados durante o processo de inicialização (além disso, todos os programas aqui são executados quando o Pi é desligado ou reinicializado). Adicione o script a ser executado na inicialização ao diretório init.d usando os seguintes comandos –
sudo cp /home/pi/securitysystem.py /etc/init.d/
Vá para o diretório init e abra o script python executando os seguintes comandos –
cd /etc/init.d
sudo nano menu.py
Adicione as seguintes linhas ao script python para torná-lo um Linux Standard Base (LSB) –
# /etc/init.d/sample.py
### INFORMAÇÕES DE INÍCIO
# Fornece: sample.py
# Início obrigatório: $remote_fs $syslog
# Parada obrigatória: $remote_fs $syslog
# Início padrão: 2 3 4 5
# Parada padrão: 0 1 6
# Breve descrição: Iniciar o daemon no momento da inicialização
# Descrição: Habilita o serviço fornecido pelo daemon.
### FIM INFORMAÇÃO DE INÍCIO
Torne o script python no diretório init executável alterando sua permissão executando o seguinte comando –
sudo chmod +x menu.py
Em seguida, execute o seguinte comando –
padrões sudo update-rc.d menu.py
Em seguida, reinicie o Pi executando o seguinte comando –
sudo reiniciar
Qualquer um dos métodos acima pode ser usado para executar o script python na inicialização. Agora o Pi 3 pode ser conectado ao monitor onde os pedidos do cliente devem ser exibidos. O script python tem os seguintes destaques principais –
1. Importe bibliotecas para MQTT e GPIO
importar paho.mqtt.client como mqtt
importar paho.mqtt.publish como publicar
importar RPi.GPIO como GPIO
2. Crie um array chamado menu, adicione itens de menu nele e envie-o
menu_items=(“Café”,
“Chá”,
“Arroz Maxixano”,
“Veggie Grelhado Que”,
“Pizza de queijo”,
“Aloo Tikki Hambúrguer”,
“Batatas fritas”,
)
preço_item=(200,130,100,400,200,55,90)
Enviando a matriz
menu de definição :
para i no intervalo(0,len(menu_items)):
#print str(i+1) +”:”+ menu_items(i)+ “:” +str(item_price(i))
menu_send = (str(i+1) +”.”+ menu_items(i)+ “:” +str(item_price(i)) + “$”)
publicar.single(“FromServer”, menu_send, hostname=broker_ip)
3. Envie resposta ao servidor de acordo com os dados recebidos
elif ('m' na mensagem):
contagem = (contagem + 1)
oldstr = mensagem
#print oldstr
tim1 = oldstr.replace(“m”, “0”)
#print tim1
tim1 = int(tim1)
tempo1 = tempo1 +30
m = ”minutos”
se(tim1>60):
tim1 = (tim1/60)
m = ”hora”
abc =str(tim1)
#imprimir abc
order = (“O pedido estará pronto em:”+abc+m)
if(tim2>len(menu_items)):
publish.single(“FromServer”, “Pedido errado! Selecione um item de menu válido”, hostname=broker_ip)
4. No final do script essas linhas cuidam das conexões com o corretor
cliente = mqtt.Cliente
cliente.on_connect=on_connect
cliente.on_message=on_message
cliente.connect(broker_ip, broker_port, 60)
cliente.loop_forever
Baixe e confira o código do aplicativo no Android Studio. Em seguida, experimente o código python no Raspberry Pi. Este é um sistema simples de gerenciamento de pedidos de hotel que utiliza o protocolo MQTT para receber e gerenciar pedidos de comida.
No próximo tutorial, aprenda sobre o protocolo IMAP.
Código-fonte do projeto
###
//Program to
import paho.mqtt.client as mqtt
import paho.mqtt.publish as publish
import random
import thread
import time
import time
import RPi.GPIO as GPIO ## Import GPIO library
import os
os.system('clear')
############################# Raspberry Pi GPIO ############################
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD) ## Use board pin numbering
GPIO.setup(8, GPIO.OUT) ## Setup GPIO Pin 8 to OUT
GPIO.setup(10, GPIO.OUT) ## Setup GPIO Pin 10 to OUT
GPIO.setup(12, GPIO.OUT) ## Setup GPIO Pin 12 to OUT
GPIO.setup(16, GPIO.OUT) ## Setup GPIO Pin 16 to OUT
#declarations
broker_ip = "broker.hivemq.com"
broker_port = 1883
oldstr="0"
tim1 = '0'
abc="0"
cba="0"
order="0"
m = '0'
a = "ad"
b = "cb"
#Main Satrt
menu_items=("Coffee",
"Tea",
"Maxixan Rice",
"Grilled Veggie Wich",
"Cheese Pizza",
"Aloo Tikki Burger",
"French Fries",
)
item_price=(200,130,100,400,200,55,90)
count = 0
count2 = 0
count3 = 0
# The callback for when the client receives a CONNACK response from the server.
print ("""
__ __ _______ _______ _______ ___ ___ _______ _______
_ _ _ _ ___ _ _ _
___
_ ___ ___ _
_ ___
__ __ _______ ___ _______ _______ ___ _______ ___
""")
def on_connect(client, userdata, flags, rc):
#print("Connected with result code "+str(rc))
print("Connected!")
# Subscribing in on_connect means that if we lose the connection and
# reconnect then subscriptions will be renewed.
client.subscribe("ToServer")
GPIO.output(16,True) #GPIO pin will be on on the connection
GPIO.output(8,False)
GPIO.output(10,False)
GPIO.output(12,False)
# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
global count
global count2
global count3
global order
global abc
global m
message = str(msg.payload)
#print(msg.topic+" "+str(msg.payload))
if ('19932' in message.lower ):
#rand1 = random.randint(0, 4)
#publish.single("FromServer", reasponse_on_name(rand1), hostname="192.168.1.106")
menu
elif ('m' in message):
count = (count + 1)
oldstr = message
#print oldstr
tim1 = oldstr.replace("m", "0")
#print tim1
tim1 = int(tim1)
tim1 = tim1 +30
m = " minutes"
if(tim1>60):
tim1 = (tim1/60)
m = " hour"
abc = str(tim1)
#print abc
order = ("Order will be ready in:"+abc+m)
elif ('ooo' in message):
count2 = count2 + 1
count3 = count3 + 1
oldstr1 = message
#print message
tim2 = oldstr1.replace("ooo", "0")
#print tim2
tim2 = int(tim2)
#print tim2
if(tim2>len(menu_items)):
publish.single("FromServer", "Wrong Order! Please Select a valid menu Item", hostname=broker_ip)
#print (" Invalid order:"+" with id:"+str(count2))
else:
publish.single("FromServer", order, hostname=broker_ip)
print ("Custmor No."+ str(count) + " wil be here in "+ abc +" "+m),
print (" With the order of:"+menu_items((tim2-1))+" with id:"+str(count2))
print " "
if(count3==1):
GPIO.output(8,True)
GPIO.output(12,False)
if(count3==2):
GPIO.output(10,True)
if(count3==3):
GPIO.output(12,True)
GPIO.output(8,False)
GPIO.output(10,False)
count3 = 0
def menu :
for i in range(0,len(menu_items)):
#print str(i+1) +":"+ menu_items(i)+ ":" +str(item_price(i))
menu_send = (str(i+1) +"."+ menu_items(i)+ ":" +str(item_price(i)) + "$")
publish.single("FromServer", menu_send, hostname=broker_ip)
client = mqtt.Client
client.on_connect = on_connect
client.on_message = on_message
client.connect(broker_ip, broker_port, 60)
client.loop_forever
###
Vídeo do projeto