Hoy en día, la mayoría de los hoteles y restaurantes aceptan pedidos de comida online. Muchos hoteles y restaurantes facilitan la realización de pedidos por adelantado o incluso ofrecen servicios de entrega a áreas locales. En este proyecto, se diseña un sistema de gestión de pedidos de hotel en el que un cliente puede realizar pedidos por adelantado de comida utilizando una aplicación móvil y un servidor basado en Raspberry Pi gestiona el cumplimiento de los elementos del menú y los pedidos de reserva. Con cada reserva, se informa al cliente de la hora a la que estará listo su pedido, para que pueda llegar a la hora indicada y recoger su pedido.
Este sistema de gestión de pedidos de hoteles se basa en el Internet de las cosas y utiliza el protocolo MQTT para la comunicación entre la aplicación móvil y el servidor Raspberry Pi. La Raspberry Pi como servidor se instala en el Hotel y permanece conectada a Internet a través de un punto de acceso Wi-Fi. Para ello se utiliza la Raspberry Pi 3, que está equipada con un módem Wi-Fi integrado. La Raspberry Pi está conectada a un monitor donde el personal del hotel puede ver los pedidos entrantes.
La Raspberry Pi y la aplicación móvil se comunican a través de un intermediario MQTT. El corredor MQTT utilizado en este proyecto es HiveMQ. La aplicación móvil se suscribe a un tema 'FromServer' mientras publica en un tema 'ToServer'. El servidor Raspberry Pi como otro cliente MQTT se suscribe al tema 'ToServer' y publica en el tema 'FromServer'. La carga útil en el tema 'ToServer' es el elemento del menú seleccionado por el usuario en la aplicación móvil. Cuando el servidor Raspberry Pi recibe un pedido para un elemento del menú de una aplicación móvil en el tema 'ToServer', envía el número de pedido y la hora de recogida como carga útil en el tema 'FromServer'.
En Raspberry Pi, la comunicación de IoT con el corredor HiveMQ se administra mediante un script de Python, mientras que la aplicación móvil utiliza la biblioteca cliente paho-MQTT para administrar la comunicación de IoT con el corredor HiveMQ. La aplicación móvil está desarrollada en Android Studio. La aplicación tiene una única actividad donde el cliente puede seleccionar un artículo del menú para realizar el pedido.
Componentes necesarios –
1) Frambuesa Pi 3
2) Cualquier teléfono inteligente
Software requerido –
1) Sistema operativo Raspbian
2) Leafpad/GNU Nano/Python 3 IDLE (para escribir scripts en Python)
3) Android Studio (para desarrollo de aplicaciones de Android)
4) Biblioteca cliente Paho MQTT: servicio de Android (para importar a la aplicación de Android)
Diagrama de bloques -
Figura 1: Descripción general del servidor Raspberry Pi y del sistema de gestión de pedidos de hoteles IoT basado en MQTT
Conexiones de circuito –
En este proyecto se utiliza una Raspberry Pi y un Smartphone como dispositivos IoT. Ambos actúan como clientes MQTT en la red IoT, mientras que HiveMQ actúa como intermediario MQTT. La Raspberry Pi está conectada a un monitor donde muestra los pedidos recibidos a través de la aplicación móvil. La Raspberry Pi está configurada para ejecutar un script de Python al inicio. Este script de Python puede recibir pedidos como suscriptor de MQTT, mostrar los pedidos recibidos junto con el número de cliente, la hora de recogida del pedido y la identificación del pedido en el monitor de visualización y devolver el número de pedido y la hora para que el pedido esté listo como editor de MQTT para la aplicación móvil. El script de Python fue desarrollado en Python 2.7.
Figura 2: Logotipo e imagen de Raspberry Pi y MQTT
El teléfono inteligente tiene instalada una aplicación desde la cual se puede realizar un pedido. La aplicación fue desarrollada usando Android Studio. La aplicación móvil utiliza la biblioteca cliente paho-MQTT para la comunicación de IoT, como Python en el lado de administración.
Cómo funciona el circuito –
El servidor Raspberry pi está conectado al broker MQTT a través del enrutador inalámbrico del hotel. Luego, la aplicación se conecta al mismo corredor a través de la conexión a Internet del teléfono celular.
El servidor Raspberry pi ejecuta un script de Python que se conecta al corredor MQTT mediante la biblioteca paho-MQTT. El script contiene el elemento del menú. Ahora, cuando la aplicación móvil está conectada al corredor, envía una cadena de señal en un tema "ToServer", el servidor Raspberry pi está suscrito al mismo tema y recibe esta señal. Ahora el servidor responde con los elementos del menú del tema “FromServer” que está suscrito a la App. De estos elementos del menú cuando un cliente solicita algo va al Servidor y si los datos son válidos le envía al usuario la hora en la que está. El pedido estará listo.
Guía de programación –
En este proyecto se desarrolla una aplicación móvil para un teléfono inteligente y un script en Python para ejecutar en Raspberry Pi. La aplicación móvil desarrollada aquí es una aplicación para Android. Para desarrollar aplicaciones móviles, primero descargue e instale Android Studio. Abra Android Studio y cree un nuevo proyecto. Asigne un nombre al proyecto: Hotel Order System y proporcione el nombre de cualquier empresa. El nombre de la empresa también puede ser el nombre del desarrollador. Haga clic en Siguiente. En la pantalla Dispositivos Android de destino, mantenga los valores predeterminados y haga clic en Siguiente. Seleccione el SDK mínimo admitido por el teléfono inteligente en este caso. En la pantalla Agregar una actividad al móvil, seleccione Actividad vacía y haga clic en Siguiente. En la pantalla Configurar actividad, mantenga los valores predeterminados y haga clic en Finalizar. Abra la ventana del proyecto navegando a Ver > Ventanas de herramientas > Proyecto, si aún no está abierto, seleccione Vista de Android. Aquí se puede ver que el proyecto contiene los siguientes archivos principales:
app > java > com.example.themenu > MainActivity: esta es la actividad principal (el punto de entrada de la aplicación). Cuando la aplicación se compila y ejecuta, el sistema inicia una instancia de esta actividad y carga su diseño.
app > res > diseño > Activity_main.xml: este archivo XML define el diseño de la interfaz de usuario de la actividad.
app > manifests > AndroidManifest.xml: El archivo de manifiesto describe las características fundamentales de la aplicación y define cada uno de sus componentes.
Gradle Scripts > build.gradle: Habrá dos archivos con este nombre: uno para el proyecto y otro para el módulo “app”. Cada módulo tiene su propio archivo build.gradle, pero este proyecto actualmente solo tiene un módulo.
Navegue hasta la pestaña Activity_main.xml si aún no está abierta. Asegúrese de que la pestaña Diseño esté abierta en la vista Activity_main.xml. En res -> diseño -> actividad_main.xml, agregue los elementos de diseño que incluyen dos widgets de vista de texto, una vista de desplazamiento, una vista de lista, dos textos de edición y un botón. Hay una única actividad en esta aplicación.
Descargue la biblioteca cliente Paho-MQTT - Servicios de Android. Luego abra la aplicación > manifiestos > AndroidManifest.xml y agregue permisos y el cliente Paho-MQTT como servicio de Android.
Luego abra MainActivity.java y anote el código Java de la aplicación. El código Java tiene los siguientes aspectos destacados principales:
1. La biblioteca y sus funciones se utilizan para suscribirse al tema "FromServer" y publicar en el tema "ToServer".
Cadena estática MQTTHOST = “tcp://broker.hivemq.com:1883”;
Cadena topicStr = “ToServer”;
Cadena topicSub = “DesdeServidor”;
2. La aplicación recibe los elementos del menú del servidor.
3. Luego, estos elementos del menú se muestran en la pantalla de la aplicación.
menuArray.add(new String(message.getPayload));
Adaptador de matriz adaptador = nuevo ArrayAdapter (MainActivity.this, android.R.layout.simple_list_item_1, menuArray);
4. Ahora en la aplicación hay dos campos que reciben entrada de texto y estas entradas se envían al servidor.
msgToserver = (EditText)findViewById(R.id.orderno);
mensaje = “ooo”+ msgToserver.getText .toString;
client.publish(tema, mensaje.getBytes, 0, falso);
5. El servidor responde según la consulta.
Para obtener más detalles sobre cómo utilizar la biblioteca cliente MQTT – Servicio Paho Android para comunicarse con el agente HiveMQ, consulte el siguiente tutorial –
Enciclopedia de la biblioteca cliente MQTT – Servicio Paho Android
La Raspberry Pi funciona como otro cliente MQTT. Ejecuta un script en Python que funciona como una utilidad de gestión de pedidos de hotel. En primer lugar, es necesario cargar la Raspberry Pi con un sistema operativo. El sistema operativo oficial Raspberry Pi, Linux Raspbian, está instalado aquí. Durante la instalación del sistema operativo, la Raspberry Pi debe estar conectada a un monitor mediante un cable HDMI y un teclado y mouse a través de puertos USB.
Para instalar el sistema operativo Raspbian en una tarjeta MicroSD, primero descargue la imagen más reciente del sistema operativo Raspbian desde el sitio web de Raspberry Pi en el siguiente enlace:
Sistema operativo Raspbian
Copie la última imagen del sistema operativo Raspbian a la tarjeta MicroSD. Si la tarjeta MicroSD utilizada es de 32 GB o menos, se debe formatear en FAT32 (sistema de archivos) antes de copiar la imagen, o si la tarjeta MicroSD tiene más de 32 GB, se debe formatear en exFAT antes de copiar la imagen. Extrae el Zip del sistema operativo y cópialo en la tarjeta MicroSD. La imagen se puede escribir en la tarjeta conectándola a una computadora portátil o PC mediante un lector de tarjetas MicroSD. Después de copiar la imagen extraída, inserte la tarjeta en la ranura MicroSD como se muestra a continuación:
Fig. 3: Imagen típica de la ranura para tarjeta MicroSD de Raspberry Pi 3
Conecte la Raspberry Pi a un monitor mediante un cable HDMI, un teclado y un mouse. Encienda la tarjeta conectándola a un adaptador de corriente. El LED rojo en la placa comenzará a parpadear y el sistema operativo comenzará a iniciarse desde la tarjeta MicroSD. El proceso de inicio se mostrará en el monitor y una vez que se complete el inicio, el LED verde se iluminará en la Raspberry Pi. Después de instalar con éxito el sistema operativo Raspbian en Raspberry Pi, se recomienda realizar una actualización de software. Esto se puede hacer ejecutando los siguientes comandos de Linux en la Terminal de Linux:
$ sudo apt-obtener actualización
$ sudo apt-obtener actualización
Después de instalar Raspbian, es hora de escribir y ejecutar scripts de Python en Raspbian. Se puede escribir un script de Python en Raspbian usando un editor de texto como Leafpad o GNU Nano. El script de Python también se puede escribir utilizando el IDE de Python estándar, como Python 2 IDLE o Python 3 IDLE. Abra Python 3 IDLE navegando por Menú -> Programación -> Python 3 IDLE. Se abrirá una ventana llamada Python 3.4.2 Shell. Escriba los scripts de Python y guárdelos en un directorio.
El script de Python escrito para este proyecto debe ejecutarse al inicio cuando el Pi 3 está encendido. El script ejecuta un bucle infinito para que nunca termine. Existen algunos métodos mediante los cuales se puede configurar Raspberry Pi para ejecutar un script de Python al inicio. Se puede utilizar cualquiera de los siguientes métodos:
1) Edición de rc.local –
Se pueden agregar comandos al archivo /etc/rc.local para ejecutar un programa o comando cuando se inicia Raspberry Pi. Esto es especialmente útil si el Pi necesita conectarse a una fuente de alimentación sin cabeza y ejecutar un programa sin configuración o inicialización manual. El archivo debe editarse con root ejecutando los siguientes comandos en la Terminal de Linux:
sudo nano /etc/rc.local
Ahora agregue comandos para ejecutar el script de Python usando la ruta completa del archivo y agregue un signo comercial al final del comando para que el script se ejecute en un proceso separado y la inicialización pueda continuar. Se debe agregar el siguiente comando donde el script de Python se guarda como menu.py –
sudo python /home/pi/menu.py &
salida 0
El comando debe agregarse justo antes de la línea de salida 0 en el archivo rc.local.
2) Edición de .bashrc –
.bashrc es un archivo oculto en la carpeta de inicio que contiene opciones de configuración del usuario. Abra el archivo .bshrc ejecutando los siguientes comandos en la terminal de Linux:
sudo nano /home/pi/.bashrc
Agregue las siguientes líneas después de la última línea del archivo:
echo ejecutándose al inicio
sudo python /home/pi/menu.py
3) Agregar script al directorio init.d –
El directorio init.d contiene los scripts que se inician durante el proceso de arranque (además, todos los programas aquí se ejecutan cuando el Pi se apaga o reinicia). Agregue el script que se ejecutará al inicio al directorio init.d usando los siguientes comandos:
sudo cp /home/pi/securitysystem.py /etc/init.d/
Vaya al directorio de inicio y abra el script de Python ejecutando los siguientes comandos:
CD /etc/init.d
sudo nano menu.py
Agregue las siguientes líneas al script de Python para convertirlo en una base estándar de Linux (LSB):
# /etc/init.d/sample.py
### INFORMACIÓN DE INICIO
# Proporcionar: muestra.py
# Inicio obligatorio: $remote_fs $syslog
# Parada obligatoria: $remote_fs $syslog
# Inicio predeterminado: 2 3 4 5
# Parada predeterminada: 0 1 6
# Breve descripción: iniciar el demonio en el momento del arranque
# Descripción: Habilita el servicio proporcionado por el demonio.
### INFORMACIÓN FINAL INICIO
Haga ejecutable el script de Python en el directorio de inicio cambiando su permiso ejecutando el siguiente comando:
sudo chmod +x menú.py
Luego ejecute el siguiente comando:
valores predeterminados sudo update-rc.d menu.py
Luego reinicie el Pi ejecutando el siguiente comando:
reiniciar sudo
Cualquiera de los métodos anteriores se puede utilizar para ejecutar el script de Python al inicio. Ahora el Pi 3 se puede conectar al monitor donde se mostrarán los pedidos de los clientes. La secuencia de comandos de Python tiene los siguientes aspectos destacados principales:
1. Importar bibliotecas para MQTT y GPIO
importar paho.mqtt.client como mqtt
importar paho.mqtt.publish cómo publicar
importar RPi.GPIO como GPIO
2. Cree una matriz llamada menú, agregue elementos de menú y envíela.
menu_items=(“Café”,
"Té",
“Arroz Maxixano”,
“Que Vegetal A La Parrilla”,
"Pizza de queso",
“Hamburguesa Aloo Tikki”,
"Papas fritas",
)
precio_artículo=(200,130,100,400,200,55,90)
enviando la matriz
menú de configuración:
para i en rango(0,len(menu_items)):
#imprimir cadena(i+1) +”:”+ elementos_menú(i)+ “:” +cadena(precio_artículo(i))
menu_send = (cadena(i+1) +”.”+ menu_items(i)+ “:” +cadena(item_price(i)) + “$”)
publicar.single(“DesdeServidor”, menu_send, nombre de host=broker_ip)
3. Enviar respuesta al servidor según los datos recibidos.
elif ('m' en el mensaje):
contar = (cuenta + 1)
oldstr = mensaje
#imprimir cadena antigua
tim1 = oldstr.replace(“m”, “0”)
#imprimir tiempo1
tim1 = int(tim1)
tiempo1 = tiempo1 +30
m = "minutos"
si(tim1>60):
tim1 = (tim1/60)
m = "hora"
abc = cadena (tim1)
#imprimir abc
order = (“El pedido estará listo en:”+abc+m)
if(tim2>len(menu_items)):
publicar.single(“FromServer”, “¡Pedido incorrecto! Seleccione un elemento de menú válido”, hostname=broker_ip)
4. Al final del script, estas líneas se encargan de las conexiones con el corredor.
cliente = mqtt.Cliente
client.on_connect=on_connect
client.on_message=on_message
cliente.connect(broker_ip, broker_port, 60)
cliente.loop_forever
Descargue y verifique el código de la aplicación en Android Studio. Luego prueba el código Python en Raspberry Pi. Este es un sencillo sistema de gestión de pedidos de hotel que utiliza el protocolo MQTT para recibir y gestionar pedidos de comida.
En el siguiente tutorial, aprenderá sobre el protocolo IMAP.
Código fuente del proyecto
### //Programa para importar paho.mqtt.client como mqtt importar paho.mqtt.publish como publicación importar aleatoriamente importar hilo tiempo de importación tiempo de importación importar RPi.GPIO como GPIO ## Importar biblioteca GPIO importarlos sistema operativo('borrar') ############################ Raspberry Pi GPIO ################## # ######### GPIO.setwarnings (falso) GPIO.setmode(GPIO.BOARD) ## Usar numeración de pines de la placa GPIO.setup(8, GPIO.OUT) ## Configurar GPIO Pin 8 a OUT GPIO.setup(10, GPIO.OUT) ## Configurar GPIO Pin 10 a OUT GPIO.setup(12, GPIO.OUT) ## Configurar GPIO Pin 12 a OUT GPIO.setup(16, GPIO.OUT) ## Configurar GPIO Pin 16 a OUT #declaraciones broker_ip = "broker.hivemq.com" puerto_corredor = 1883 cadena antigua="0" tim1 = '0' abc="0" cba="0" orden="0" metro = '0' a = "anuncio" b = "cb" #Satrt principal menu_items=("Café", "Té", "Arroz Maxixán", "Vegetales A La Parrilla", "Pizza de queso", "Hamburguesa Aloo Tikki", "Papas fritas", ) precio_artículo=(200,130,100,400,200,55,90) contar = 0 cuenta2 = 0 cuenta3 = 0 # La devolución de llamada para cuando el cliente recibe una respuesta CONNACK del servidor. imprimir(""" __ __ _______ _______ _______ ___ ___ _______ _______ _ _ _ _ ___ _ _ _ ___ _ ___ ___ _ _ ___ __ __ _______ ___ _______ _______ ___ _______ ___ """) def on_connect(cliente, datos de usuario, banderas, rc): #print("Conectado con el código de resultado "+str(rc)) imprimir("Conectado!") # Suscribirse en on_connect significa que si perdemos la conexión y # vuelva a conectarse y se renovarán las suscripciones. cliente.subscribe("AlServidor") GPIO.output(16,True) #El pin GPIO estará activado en la conexión GPIO.salida(8,Falso) GPIO.salida(10,Falso) GPIO.salida(12,Falso) # La devolución de llamada para cuando se recibe un mensaje PUBLICAR del servidor. def on_message(cliente, datos de usuario, mensaje): recuento global recuento global2 recuento global3 orden global abc global global m mensaje = str(msg.carga útil) #print(msg.topic+" "+str(msg.payload)) si ('19932' en mensaje.inferior): #rand1 = aleatorio.randint(0, 4) #publish.single("FromServer", reasponse_on_name(rand1), hostname="192.168.1.106") menú elif ('m' en el mensaje): contar = (cuenta + 1) oldstr = mensaje #imprimir cadena antigua tim1 = oldstr.replace("m", "0") #imprimir tiempo1 tim1 = int(tim1) tim1 = tim1 +30 m = "minutos" si(tim1>60): tim1 = (tim1/60) m = "hora" abc = cadena(tim1) #imprimirabc pedido = ("El pedido estará listo en:"+abc+m) elif ('ooo' en el mensaje): contar2 = contar2 + 1 contar3 = contar3 + 1 oldstr1 = mensaje #imprimir mensaje tim2 = oldstr1.replace("ooo", "0") #imprimir tim2 tim2 = int(tim2) #imprimir tim2 if(tim2>len(menu_items)): publicar.single("FromServer", "¡Pedido incorrecto! Seleccione un elemento de menú válido", hostname=broker_ip) #print ("Orden no válida:"+" con id:"+str(count2)) demás: publicar.single("DesdeServidor", orden, nombre de host=broker_ip) print ("Nº de cliente."+ str(count) + " estará aquí en "+ abc +" "+m), print ("Con el orden de:"+menu_items((tim2-1))+" con id:"+str(count2)) imprimir " " si(cuenta3==1): Salida.GPIO(8,Verdadero) GPIO.salida(12,Falso) si(cuenta3==2): Salida.GPIO(10,Verdadero) si(cuenta3==3): Salida.GPIO(12,Verdadero) GPIO.salida(8,Falso) GPIO.salida(10,Falso) cuenta3 = 0 menú definido: para i en rango(0,len(menu_items)): #print str(i+1) +":"+ menu_items(i)+ ":" +str(item_price(i)) menu_send = (cadena(i+1) +"."+ menu_items(i)+ ":" +cadena(item_price(i)) + "$") publicar.single("Desde el servidor", menu_send, nombre de host = broker_ip) cliente = mqtt.Cliente client.on_connect = on_connect client.on_message = on_message cliente.connect(broker_ip, broker_port, 60) cliente.loop_forever ###
