Sistema de gerenciamento de pedidos de hotéis/restaurantes baseado em servidor Raspberry Pi em IoT – IOT Parte 46

26 juin 2024 Roberto Magalhães

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 –

Visão geral do Raspberry Pi Server e do sistema de gerenciamento de pedidos de hotéis IoT baseado em MQTT

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 


###