The traditional method commonly used in hotels is to accept customer orders, write
them on paper, and then place the order on the kitchen area. A food ordering system is
proposed that uses a portable device placed on each table and used for ordering in a
At this time of pandemic, the human-human interaction is deemed to be unsafe and
unhealthy. Similarly, there needs an extra human resource, economic resource and
various other resources for the continuation of traditional menu display and ordering
system at restaurants and hotels. So, this system tends to change the menu digitalization
and ordering system that are exhausting and converts them into something exciting.
Something more convenient to digital usage, wireless connections and a screen touch
ordering system with a backend at the kitchen that updates. This can be a new practice
in scenario of Nepali food chains and restaurants.
Basically, the touch screen or display is kept at consumer end for various purposes and
display of menu. This is attached to the Arduino Uno for processing that data and sends
the data using RF transmitter at the consumer end. At the receiving end, Arduino Uno
is interfaced with RF receiver and other components to process the received data at the
kitchen end. A display of data is done at the monitor or similar displaying device. In
this way, the order is received at kitchen end which is basically a digital system for
replacing traditional menu and order

Problem Definition

The main problem in the food service industry is that restaurants cannot achieve
efficiency due to the more effective use of technology and automation in daily
operations. In all restaurants, employees must accept orders, process orders and use
traditional menu submission methods. Nowadays, the number of restaurants is
increasing, and they also need very fast processing to provide food to customers. As the
number of customers increases, since the current situation is crazy for customers, more
personnel will be needed. Restaurants/hotels are also unable to change the menu
printout at a short time span.
The traditional method commonly used in hotels is to accept customer orders, write on
paper, and then place the order on the kitchen area. This process usually takes longer
and is not very convenient. Although this system is simple; this can lead to errors in the
order entry as well as in the calculation. Even the waiter’s handwriting is difficult to
interpret at times. To overcome these limitations in the manual system, the system is
developed to automate the food ordering process. A food ordering system is proposed,
which uses a portable device placed on each table and used for ordering in a restaurant.

Project Objectives

The general objective of this project is to contribute to the development of a digital
menu and automatic ordering system. The general objective can be broken down into
the following:

  1. To develop a system for better user experience with interactivity.
  2. To tailor the smooth operation with less delay and reduction in operational confusion.
  3. To integrate proper methods and methodologies which are used for designing and
    developing the system in systematic approach.
  4. To integrate technology and automation in food service industry for efficiency.


With the advancement of technology, people are used to the touchscreen interface these
days. The user can access the navigation simply by touching the screen. With a slight
change in this project, this system can be widely used in various public places such as
cafeterias, pubs, canteens and theaters too. Some of the points to be noted for scope are:
1.4.1 Customizable Integration and Smooth Operation of Restaurants: Digital
system makes sure of the smooth operation going from the customer to the kitchen and
keeps the operations efficient using minimal time-frame for transmission of orders and
information. Rapid customer support is essential for a digital system in any case. With
this system, the operators have freedom of creating order menu, design changes and
other functional changes to the system. It can have other useful features incorporated
and are easy for regular upgrades as per the requirement.
1.4.2 Automation in Food Service Industry: With the main aim of reduction of
resources and scalability, this system is introduced. This system is highly scalable and
can support maximum numbers of customers with minimal resources used. It also
highly improves the kitchen efficiency with less interruption and can be a highly
reliable investment both operationally and financially.

Report Organization

This report consists of 10 chapters. Chapter 1 is the introduction to the project, contains
the problem definition, goals and motivation. Chapter 2 reviews three types of ordering
systems and compares them to the proposed system. Chapter 3 includes the various
methodologies that discusses the theoretical background, operation and features of the
system. Chapter 4 describes the requirement and feasibility of the system in general.
Chapter 5 explains the methods and architectures used in the system. The design of the
system is shown using various diagrams in this chapter. Chapter 6 has implementation
details based on hardware interfacing including various schematic diagrams. Chapter 7
to 10 discusses the completion and improvements of the project.


Since we have realized that hospitality and service have a huge impact on the way
restaurants operate, many orders and service plans are seemed to be existing. Other
available ordering system which are being used are discussed and sorted out as follows:

Traditional Ordering System

This method is that the customer shows the required menu to the waiter, the waiter
accepts the order on paper, and then sends the order to the kitchen department in person,
and then delivers the food to the customer which is time-consuming process. This
results in wasted paper and also requires reprinting of all menu cards.
In addition, it is impractical to reprint all menu cards to make small changes to the menu
cards. The printed menu card cannot be changed. After a few days, the menu card loses
its graceful and attractive appearance.

Self-Service System

Self-service or self-ordering in restaurants refers to restaurants that use technologies
such as the Internet and kiosks to take orders from customers. Generally, users like self-
service because of the speed and convenience of orders, also these transactions can
minimize misunderstandings. A self-service restaurant is a restaurant in which guests
serve themselves the food they want and thus have the option of creating a flexible
The advantage is that there are no funding issues because the transaction is done online.
The disadvantage is the high cost of installing, authorizing and developing software.

Online Ordering System

Customers can choose their favorite restaurant online, view restaurant menus, and place
orders through the website. One has two options for ordering a home delivery or pickup.
The delivery in the restaurant delivers the food to the customer’s house. On the other
hand, if the customer chooses to collect food, the purchaser can go to the restaurant to
collect food.
However, there are some disadvantages of this system as the delivery system adds up
to the expenses of restaurants, change of hospitality, packaging materials may degrade
the quality of food and there may be some adverse effects of such on health. So, it all
adds as a part of online food ordering systems.


Theoretical Background

Working of wireless RF module

Generally, wireless systems must operate within a certain distance, and they must
transmit a certain amount of information at a certain data rate. The RF module is
small and has a wide operating voltage range from 3 V to 12 V. RF modules are 433
MHz RF transmitter and receiver modules. The transmitter draws no power when
transmitting logic zero while fully suppressing the carrier frequency thus consume
significantly low power in battery operation. When logic one is sent carrier is fully on
to about 4.5mA with a 3V power supply. The data is sent one by one from the
transmitter, which is received by the configured receiver. The transmitter and receiver
are connected to the two microcontrollers for data transmission.

Working of Serial Peripheral Interface

The serial peripheral interface (SPI) is a synchronous serial communication interface
that is best suited for short distances. Transmission is done at relatively high speeds as
it has no any protocol addressed for communication. SPI runs on one master side that
generates the clock, with one or many slaves, usually the devices outside the main
processor. Each slave added to the system needs an additional chip select I/O pin on
the master component.

Working of touch LCD display

A touchscreen is a two-dimensional sensitive device made up of two sheets of material
that are slightly separated from each other by a spacer. The usual construction is a sheet
of glass that provides a stable bottom layer and a polyethylene (PET) film as a flexible
top layer. Two sheets are lined with resistive material, usually a metal compound called
Indium tin oxide. The ITO is placed finely and evenly onto both the glass plate and the
PET layer. Small bumps, called spacing points, are then placed on the side of the glass
over the resistive ITO coating to prevent the PET film from sagging and causing
accidental or incorrect touches. When the PET film is pressed, the two resistance
surfaces meet. The location of this meeting can be read by the touchscreen control
circuit as the controller reads the X and Y position many times per second, so the user
can quickly move their touch across the screen and the data is captured.

Operation of the system

At the customer end, each table has a touch screen device that displays each item in
a menu provided by the restaurant.

Each touch screen is interfaced with Arduino Uno that processes the data from touch
to be transmitted to the receiving end.

This end is connected to the transmitting RF module that transmits the data
wirelessly to the receiving end.

At the receiving end, there exists one RF receiver that receives the data transmitted
wirelessly and sends it to the microprocessor for further processing.

Arduino Uno processes the received data and processes the request by the customers
at each transmitting end.

Arduino further sends data to the display device and database that is at the receiving

Features of the system

A user-friendly system that provides latest information to customers with
interactivity as feature.
•Highly reliable, flexible and secure implementation of wireless transmission.
•Multiple orders can be received and processed simultaneously.
•Digital Menu can be easily updated and configured as per the requirement.


Project Requirements

In this section, the requirements of the system are discussed in detail. Furthermore,
project requirement is separated into two parts, i.e. Hardware Requirement and
Software Requirement; basically, all the hardware components interfaced to develop
the system are placed in the hardware requirement. Software requirement is the detail
on the software that are used for the operations and development of the system.

Hardware Requirements

Arduino Uno

Arduino Uno is important electronics board that consists of USB interface, 14 digital
I/O pins, 6 analog pins, and Atmega328 microcontroller that also supports serial
communication using Tx and Rx pins. Out of 14 I/O pins, 6 pins can be used for PWM
output. Arduino Uno is based on AVR microcontroller called Atmega328. This
controller comes with 2KB SRAM, 32KB of flash memory, and 1KB of EEPROM.
Arduino Board comes with 14 digital pins and 6 analog pins. On-chip ADC is used to
sample these pins, also a 16 MHz frequency crystal oscillator is equipped on the board.
When the nature and functionality of the task becomes complex, the Micro-SD card can
be added to the boards to store more information.
This board has a built-in control function that keeps the voltage under control when the
device is connected to the external device. It’s an open source platform where anyone
can modify and optimize the board based on the number of instructions and tasks one
wants to perform. It enables designers to control and recognize external electronic
devices in the real world.

SPI LCD Touchscreen

In the system, we have used a 2.8″ TFT LCD is a full color display with a resolution of
240 x 320 pixels. It uses the ILI9341 controller with SPI interface that also includes a
resistive touchscreen with built-in XPT2046 controller. This display contains the SPI
interface which enables quick updates of the display. It is a 4-wire interface that
contains a CS (Chip Select). The touch screen makes use of the SPI interface and can
be connected to the same pins as the screen. It uses a separate CS to avoid conflicts.
These modules are compatible with a 14-pin header on the back that connects to a 14-
pin socket that allows the display to be connected when the display is to be mounted. It
works on 3.6 to 5.5V module operation with 3.3V logic compatibility.
For best performance, a hardware SPI interface is used whenever possible to get the
fastest screen updates.

RF Module

RF transmitter-receiver pair operates at a specific frequency of 433MHz. The RF
transmitter receives serial data and sends it to the receiver via an antenna connected to
the fourth pin of the transmitter. If the logic 0 is applied to the transmitter, there is no
current flow. If the logical 1 is applied to the transmitter, the transmitter is switched on
and then there is high-power supply in the range of 4.5 mA with 3V supply voltage.
The RF transmitter is a resonator that is tuned to operate on 433 MHz that consists of
switching transistor and a few passive components. The RF receiver is a receiver
module that consists of an RF tuned circuit and a couple of OP Amps to amplify the
received carrier wave from the transmitter.
In our system, we use RF modules to transmit and receive the data because it has large
area of applications and RF signals travel from the transmitter to the receiver end even
when there is an obstruction.

Software Requirements

Arduino IDE

Arduino IDE is an open-source programming tool that allows users to download or
write code. With this program one can work in real time. We can see that the Arduino
IDE offers compatibility with many Arduino-based boards. This tool can be deployed
on Windows, Mac and Linux operating systems. This IDE also has advanced
functionalities that includes board module options, direct sketching, online sharing,
integrated libraries, etc. This IDE (Integrated Development Environment) is an element
of Arduino Production, an online platform that developers can use to annotate code,
access tutorials, customize development boards, and share projects. Arduino IDE
ensures smooth user progress and support developers every step of the way from
conception to implementation. It also has integrated web editor that allows one to write
code and upload sketches to any official Arduino board from web browser.


XAMPP stands for Cross-Platform (X), Apache (A), MySQL (M), PHP (P) and Perl
(P). XAMPP is an easy to implement package that includes the Apache internet server,
PHP, XDEBUG and the MySQL database. In this way one can create the environment
in which one can use servers and database on a computer. The modern XAMPP model
is available on the XAMPP website. XAMPP software is compatible for Linux,
Windows and other OS platforms. It’s a simple and lightweight Apache distribution
software that makes it extraordinarily easy for developers to set up a local web server
for various purposes.


Node.js is a cross-platform open-source runtime for developing server and web
packages. Node.js packages are written in JavaScript and may run in the Node.js
runtime on OS X, Microsoft Windows and Linux. Node.js, additionally provides an
extension library containing diverse JavaScript modules, which greatly simplifies the
improvement of Web packages using Node.js.

Feasibility Study

The project includes a complete and innovative system designed and developed for a
restaurant that allows the management of menus and orders. It is an interactive system
for the user so that it can be accessed through that individually placed touchscreen
device. The system can also be commercialized as it has wider area of application being
a new technology in context of Nepal. Developed system is open source and the
hardware is affordable. Therefore, this system can be used with minimal cost and
without technical expertise.


In this section, we have put forward the main ideology behind the system, here it
includes system flow chart to show stepwise important steps for working of the system.
Similarly, block diagram is included for diagrammatic representation of the system in
full working condition.

System Block Diagram

As, we have transmitting part and receiving part, hence we need block diagram of both
the sides. The transmitting part consists of a microprocessor board i.e., Arduino Uno
for processing the data and execute various functions in the system, SPI TFT touch
display is kept for digital menu and interacting component to the customers and RF
transmitter unit is used to transfer the data wirelessly from transmission unit to the
receiving one. Below is the block diagram of transmitter side:

The receiving unit includes an Arduino Uno microprocessor board which processes the
data and executes various function in the system and RF receiving unit is used to receive
the transmitted data wirelessly from transmission unit to the receiving one. Here, the
data received is transferred to the database for other useful purposes. Below is the block
diagram of transmitter side:

System Flow-Chart

System flow chart shows the whole work-flow process and shows the sequence of
functions that is being done in the system. It also comprises of two sides; receiving and
the transmitting part. Here, the flow-chart is used to define and simplify the process that
is being implemented in the system.

Flow-chart of transmitting part
Flow-chart of receiving part


In this section, one can get the proper idea of the implementation of the system as a
whole, united together acting for a common functioning. Various components as
discussed in requirement system are interfaced to unite together as a single unit that
acts as a digital menu and automatic ordering system as a whole. Using the jumper wire
each component are interfaced individually with the microprocessor unit then, later
come together to form a system.
Basic idea behind working of each component individually is seen and implemented
before putting it together as a system. Implementation details of the system are shown

Hardware Interfacing

Interfacing with the TFT touch LCD

As we have used ILI9341 TFT LCD touch display with 14 pins for signal line; 9 for
regular TFT LCD signal and 5 for touch screen signal lines. We have connected Vcc of
TFT display to 5V of Arduino, GND is connected with the GND itself, CS of LCD is
connected to A5 pin, RST to A4, DC to A3, MOSI pin to the pin 11, SCK to pin 13,
LED to A0 pin and MISO to pin 12 from TFT display to Arduino Board respectively.
These were the interfacing of regular TFT display without touch function.
For the touch functionality, we connect the remaining five pins to the Arduino
microcontroller board as follows; T_SCK is connected to the pin 3, T_CS is connected
to the pin 2, T_DIN is connected to pin 5, T_DO is connected to pin 4, T_IRQ is
connected to the pin 6 from TFT Screen to Arduino Board respectively. Here, we must
make use of core graphics library (), hardware-specific library
() and touch screen library () which are
important to control the TFT touch lcd using ILI9341 drivers.

Interfacing with the RF Module

In this system, RF transmitter-receiver pair is used for the communication from one
microcontroller board to the other one. RadioHead is a library that allows one to easily
transfer data between Arduino boards. It is versatile and can be used to control all types
of radio communication equipment, including the 433 MHz module. The library is used
as () Here, 433 MHz RF signal is being used without the connection of
antenna as we require smaller distance to be covered. Interfacing is done as;

For the transmitter side: The wiring of the transmitter is simpler because it has only
three connections: the Vcc pin is connected to the 5V pin, and the GND is connected to
the Arduino ground. The data input pin must be connected to the digital pin 12 of the
Arduino, and pin 12 must be used. By default, the library uses this pin for data input.

For the receiver side: Likewise, only three connections need to be established.
Connect the Vcc pin to the 5V pin on the Arduino and connect GND to ground. One of
the two middle pins of the data pin should be connected to digital pin 11 of Arduino
respectively for the data output.



#include <VirtualWire.h> // Rf library
#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_SPI.h> //Hardware-specific library
#include <LCDWIKI_TOUCH.h> //touch screen library

//paramters define
//#include <stdint.h>
//char *msg ; 
#define MODEL ILI9341
#define CS   10
#define CD   9    
#define RST  8
#define MOSI 11
#define MISO 12
#define SCK  13
#define LED  -1   

//touch screen paramters define
#define TCS   2
#define TCLK  3
#define TDOUT 4
#define TDIN  5
#define TIRQ  6

//define pins of interface
LCDWIKI_SPI my_lcd(MODEL,CS,CD,MISO,MOSI,RST,SCK,LED); //model,cs,dc,miso,mosi,reset,sck,led

//define pins of touch mode as follow:
LCDWIKI_TOUCH my_touch(TCS,TCLK,TDOUT,TDIN,TIRQ); //tcs,tclk,tdout,tdin,tirq
#define BLACK        0x0000  
#define BLUE         0x001F  
#define RED          0xF800  
#define GREEN        0x07E0  
#define CYAN         0x07FF  
#define MAGENTA      0xF81F  
#define YELLOW       0xFFE0  
#define WHITE        0xFFFF  
#define NAVY         0x000F  
#define DARKGREEN    0x03E0  
#define DARKCYAN     0x03EF  
#define MAROON       0x7800 
#define PURPLE       0x780F 
#define OLIVE        0x7BE0 
#define LIGHTGREY    0xC618 
#define DARKGREY     0x7BEF 
#define ORANGE       0xFD20 
#define GREENYELLOW  0xAFE5  
#define PINK         0xF81F 

//User Interface details 
#define BUTTON_R 25
#define EDG_Y 5
#define EDG_X 20

uint16_t px,py;

// We have a status line for like, is FONA working
#define STATUS_X 10
#define STATUS_Y 65

// design tft buttons
typedef struct _button_info
     uint8_t button_name[10];
     uint8_t button_name_size;
     uint16_t button_name_colour;
     uint16_t button_colour;
     uint16_t button_x;
     uint16_t button_y;     

button_info  resturent_button[15] = 

uint16_t text_x=7,text_y=6,text_x_add = 6* resturent_button[0].button_name_size,text_y_add = 8* resturent_button[0].button_name_size;
uint16_t n=0;

void show_string(uint8_t *str,int16_t x,int16_t y,uint8_t csize,uint16_t fc, uint16_t bc,boolean mode)


boolean is_pressed(int16_t x1,int16_t y1,int16_t x2,int16_t y2,int16_t px,int16_t py)
    if((px > x1 && px < x2) && (py > y1 && py < y2))
        return true;  
        return false;  

void show_menu(void)
    uint16_t i;
   for(i = 0;i < sizeof( resturent_button)/sizeof(button_info);i++)
      my_lcd.Set_Draw_color( resturent_button[i].button_colour);
      my_lcd.Fill_Circle( resturent_button[i].button_x,  resturent_button[i].button_y, BUTTON_R);
      show_string( resturent_button[i].button_name, resturent_button[i].button_x-strlen( resturent_button[i].button_name)* resturent_button[i].button_name_size*6/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_y- resturent_button[i].button_name_size*8/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_name_size, resturent_button[i].button_name_colour,BLACK,1);
   my_lcd.Fill_Rectangle(1, 1, my_lcd.Get_Display_Width()-2, 3);
   my_lcd.Fill_Rectangle(1, 29, my_lcd.Get_Display_Width()-2, 31);
   my_lcd.Fill_Rectangle(1, 1, 3, 31);
   my_lcd.Fill_Rectangle(my_lcd.Get_Display_Width()-4, 1, my_lcd.Get_Display_Width()-2, 31);
void setup(void) 
  // tft.Fill_Screen(BLACK);
//   if (!d.init())
   //Serial.println("init failed");
void send (char *message)
  vw_send((uint8_t *)message, strlen(message));
  vw_wait_tx(); // Wait until the whole message is gone

void loop(void)
  uint16_t i;
  px = 0;
  py = 0;
  if (my_touch.TP_Get_State()&TP_PRES_DOWN) 
    px = my_touch.x;
    py = my_touch.y;
  for(i=0;i<sizeof( resturent_button)/sizeof(button_info);i++)
       if(is_pressed( resturent_button[i].button_x-BUTTON_R, resturent_button[i].button_y-BUTTON_R, resturent_button[i].button_x+BUTTON_R, resturent_button[i].button_y+BUTTON_R,px,py))
            my_lcd.Fill_Circle( resturent_button[i].button_x,  resturent_button[i].button_y, BUTTON_R);
            show_string( resturent_button[i].button_name, resturent_button[i].button_x-strlen( resturent_button[i].button_name)* resturent_button[i].button_name_size*6/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_y- resturent_button[i].button_name_size*8/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_name_size,WHITE,BLACK,1);
            my_lcd.Set_Draw_color( resturent_button[i].button_colour);
            my_lcd.Fill_Circle( resturent_button[i].button_x,  resturent_button[i].button_y, BUTTON_R);
            show_string( resturent_button[i].button_name, resturent_button[i].button_x-strlen( resturent_button[i].button_name)* resturent_button[i].button_name_size*6/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_y- resturent_button[i].button_name_size*8/2+ resturent_button[i].button_name_size/2+1, resturent_button[i].button_name_size, resturent_button[i].button_name_colour,BLACK,1);  
            if(i < 12)
                 send("momo-50|-        ");
                 delay(1000); // transmit function call
                  send("pizza-350|-      ");
                  send("coke-45|-        ");
                  send("chiken-230|-     ");
                 send("berger-300|-     ");
                  send("slice-45|-       ");
                  send("roast-250|-      ");
                  send("biryani-250|-    ");
                send("ice cream-70|-   ");
                  send("omlet-50|-       ");
                  send("lassi-50|-       ");

                 send("chaat-40|-       ");  
             if(n < 13)
                  show_string( resturent_button[i].button_name,text_x,text_y, resturent_button[i].button_name_size,GREENYELLOW, BLACK,1);
                  text_x += text_x_add-1;
            else if(12 == i)
                 my_lcd.Fill_Rectangle(0, 33, my_lcd.Get_Display_Width()-1, 42);
                 show_string("ordered complete",CENTER,33,1,GREEN, BLACK,1);  

                  send("order complete   ");
            else if(13 == i)
                   my_lcd.Fill_Rectangle(0, 33, my_lcd.Get_Display_Width()-1, 42);
                  // show_string("Calling...",CENTER,33,1,GREEN, BLACK,1); 
//                  msg = "Calling waiter";
//                  transmit();
                    send("calling waiter   ");

            else if(14 == i)
                   //meg = "cancel above item";
                   send("cancel above item");
                if(n > 0)
                    text_x -= (text_x_add-1);  
                    my_lcd.Fill_Rectangle(text_x, text_y, text_x+text_x_add-1, text_y+text_y_add-2);


#include <VirtualWire.h>

byte message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages
byte messageLength = VW_MAX_MESSAGE_LEN; // the size of the message

void setup()
  //Serial.println("Device is ready");
  // Initialize the IO and ISR
  vw_setup(2000); // Bits per sec
  vw_rx_start(); // Start the receiver

void loop()
  if (vw_get_message(message, &messageLength)) // Non-blocking
  // Serial.print("Received: ");

    for (int i = 0; i < messageLength; i++)



Skip to content
Using Gmail with screen readers
New meeting
Join a meeting
1 of 4,131
js file send navayra maile txt file ma copy garera pathako xu
Sunil raut <>
Attachments10:05 AM (8 hours ago)
to me

7 Attachments


    // Prepare variables for database connection

    $dbusername = "dbuser";
    $database_name = "arduino"; // enter database username
    $dbpassword = "root";  // enter database password
    $server = "localhost"; // IMPORTANT: for XAMPP user enter "localhost", but for  online website enter its address, ie.""

    // Connect to your database

    $dbconnect = mysqli_connect($server, $dbusername, $dbpassword);
       die('Not connected : ' . mysql_error());
    //echo "Connected successfully";
    $dbselect = mysqli_select_db($dbconnect,$database_name);

    //SQL statement

  // $sql = "INSERT INTO sensor (id, value) VALUES (1,'value')";\ // for user input from website to database
  $sql = "SELECT * FROM information "; // information is table name in database 

    // Execute SQL statement

  $result =  mysqli_query($dbconnect,$sql);
      $sql_d = "DELETE FROM information WHERE id = {$_REQUEST['id']}"; // To delete data 
          echo "1 record  Deleted";
          echo "Erro deleting data";

 <!-- HTML code to display data in tabular format -->
<!DOCTYPE html>
<html lang="en">

    <meta charset="UTF-8">
    <title>Arduino data</title>
        table {
            margin: 0 auto;
            font-size: large;
            border: 1px solid black;

        h1 {
            text-align: center;
            color: #006600;
            font-size: xx-large;
            font-family: 'Gill Sans', 'Gill Sans MT',
            ' Calibri', 'Trebuchet MS', 'sans-serif';

        td {
            background-color: #E4F5D4;
            border: 1px solid black;

        td {
            font-weight: bold;
            border: 1px solid black;
            padding: 10px;
            text-align: center;

        td {
            font-weight: lighter;

        <h1>Ordered Menu List</h1>
        <!-- TABLE CONSTRUCTION-->
                <th>Ordered Item</th>
                <th>Ordered Time</th>
                <!-- <th>Price</th> -->
              <!-- <th>GFG Articles</th>  -->
            <!-- PHP CODE TO FETCH DATA FROM ROWS-->
            <?php   // LOOP TILL END OF DATA
                <!--FETCHING DATA FROM EACH
                    ROW OF EVERY COLUMN-->
                <td><?php echo $rows['id'];?></td>
                <td><?php echo $rows['data'];?></td>
                <td><?php echo $rows['time'];?></td>
                <!-- <td><?php //echo $rows['price'];?></td> -->
                 <?php echo '<td><form action = "" method = "POST"><input type = "hidden" name = "id" value ='.$rows['id'].'><input type = "submit"  name = "submit" value = "delete">
                 </form></td>'; ?>

Displaying p.php.


Skip to content
Using Gmail with screen readers
New meeting
Join a meeting
1 of 4,131
js file send navayra maile txt file ma copy garera pathako xu
Sunil raut <>
Attachments10:05 AM (8 hours ago)
to me

7 Attachments


    // Prepare variables for database connection

    $dbusername = "dbuser";
    $database_name = "arduino"; // enter database username
    $dbpassword = "root";  // enter database password
    $server = "localhost"; // IMPORTANT: for XAMPP user enter "localhost", but for  online website enter its address, ie.""

    // Connect to your database

    $dbconnect = mysqli_connect($server, $dbusername, $dbpassword);
       die('Not connected : ' . mysql_error());

    //echo "Connected successfully";
    $dbselect = mysqli_select_db($dbconnect,$database_name);

    // Prepare the SQL statement

//   // $sql = "INSERT INTO sensor (id, value) VALUES (1,'value')";\
//   $sql = "SELECT * FROM sensor ";

//     // Execute SQL statement

//   $result =  mysqli_query($dbconnect,$sql);


Displaying p.php.


  //$tn = $_POST['table'];
  $dn = $_POST['item']; // only item name enter
 // $pr = $_POST['rate'];
  $sql = "INSERT INTO information (data)  VALUES('$dn')";
    // die('1 record inserted');
    echo "1 record inserted";

    } // end of nested if statement
      echo "Error inserting data";
} // end of main if statement
<!DOCTYPE html>
<html lang="en" dir="ltr">
    <meta charset="utf-8">
    <title>Insert Data into DB</title>
     body {background-color: powderblue;}
     h1  {
       color: blue;
       text-align: center; 
       font-style: italic;
    <h1>Insert Data into DB</h1>
    <form  method="post" action="insert_data.php">
      <input type="hidden" name="submitted" value="true" />
        <legend>Insert Data to DataBase</legend>
       <!-- <label>  : <input type = "Number" name = 'table'/></label> -->
        <label> Item Name : <input type = "text" name = 'item'/></label>
       <!-- <label> Price : <input type = "Number"  name = 'rate' /></label> -->
        <!-- <lebel>Price:<input type = "Number" fname="time" /></label> -->
      <br />
      <input type = "Submit" value = "Add new Data" />




Here, we present the result and output of our project. This section presents the basic
idea of the project and it’s general behavior with the proper analysis.

Output of the System

Hence, the system acts as per the requirement of our project with minimal error. System
was able to take orders from touch display connected to the microcontroller board and
transmitted the data from transmitting unit. As, the wireless connection is used for
transmission of data using RF module, the data was transferred successfully. At the
receiving end, received data is processed by another microcontroller board. The data
was then put into database for implementation in the kitchen end. Finally, it was shown
in the output screen.

Conclusion of Analysis

The system can be used in real life project and can be commercialized as per the usage
of the food service industry. The project is economic and better than the existing system
being used in the food service industry. By using the virtual touch screen to order, one
can save paper and reduce the need to print copies of menu cards. The diners entering
the dining room no longer need the waiter to place an order. Taking up space, one can
order as per need, and can order as soon as they occupy tables.


The current system is ready to be commercialized and have many adaptations made to
the system as per the requirement. So, the system works with appreciable efficiency but
has some enhancement that can make the system more desirable. Initially, the payment
system can be added at the consumer side probably using some touchless medium
integrated to the existing system. Offering local payment options along paying with
card will offer a new dimension to this system. Furthermore, the system can integrate
“Call the Staff” option for the time when diners have any queries or require attention.
When a customer chooses this option, staffs can immediately know which table they
are being called at. UI can be improved for overall better user experience.
These enhancements can amplify the productivity of the system and benefit the
restaurants along bringing more better diner experience.


In this Automatic Menu and Ordering system, we have developed an interactive, user-
friendly food ordering system with digital menu for food service industry. This System
prioritizes the basic constraints of any food service industry which are time, hospitality
and hassle-free service system. This system eases clients to order by touching the
surface of a digital menu that is locally linked to the kitchen end with an RF module.
This System will help them to properly manage the meals of the customers, reduce the
kitchen time, also can be used to reduce delays and errors caused by waiters on orders
of customers. So, using this system will help in reducing the labor and provide more
facility for Customer to like the services of the restaurants.
This is a practical, powerful, economic and flexible system that can increase the overall
productivity of food service industry. This system is made to provide pleasant service
and customer satisfaction. It will definitely surpass people’s dining style and habits.
This can bring in more revenue for restaurants while allowing customers to better
understand what kind of food they want to have, and give them a top-notch interactive


Appendix A: Circuit Diagram

Appendix B : Circuit Connection and Still Images of System

System connection schematic
Frontend of system
Database introduced in system
Order placed in the system


Saroj Basnet
Saroj Nepal
Sunil Raut

Recommended For You

About the Author: admin