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 ###
