Mobile Scanner & Scale Checkout System

Download 70.23 Kb.
Size70.23 Kb.

Mobile Scanner & Scale Checkout System

Senior Project Proposal – First Draft

ECE 414 – Dr. Bernard Friedland

Richard Brito

Aredious Brown

Jonathan Rivera

Delivered 04/11/2013

Our device will work on a mobile platform where the customer can scan items while they shop and self checkout right from a mobile application. Our system will be beneficial to shoppers because they will not have to wait on a line to checkout and can shop while keeping a running total on their purchases. It will be beneficial to retailers in the sense that the technology in the device will encourage shoppers to buy more. The mobile application will be compatible with their everyday Smartphone and link up specifically to the store’s inventory to keep track of pricing and other information. Using the camera off the phone, the application will capture scans of the barcodes and come up with a price and weight system that will determine what the shopper has to pay as well as how much weight they are carrying in the cart.

The weight of the items in the cart will help the retailer determine if the cart contains what the shopper is paying for. When the shopper leave the store the cart will have to pass through a scale system that will determine if the weight calculated in the shopper’s bill matches the weight on the scale that is built into the cart. The employee will verify this and allow the customer to leave the store. All of this will run on a system that will extract information of the sale from the application and the scale to one centralized location at the store where the retailer can keep track of what is going on in their store.

c:\users\administrator\downloads\p1 (1).png

Figure: Basic Layout of our system that shows that the Smartphone and Store Computer both compare data on the Database and match to show transactions and verify information from the Shopping Cart/Scale system.

Technical Discussion:

Our system will have the following modules:

  1. Smartphone with Scanner App (Coded Application)

  2. Scale (Fully built circuit).

  3. Microcontroller and LCD display unit.

  4. Connectivity (Device data transfers).

  5. Software (Database system and Graphical User Interface (GUI))

Module 1: Smartphone with Scanner App

For our purpose of the project a mobile application will be designed to interact with the user in being able to scan items and have an associated weight with the total amount of items tallied. In our demo we will code the application on the Android operating system platform. This will be coded primarily in Java using the Android SDK tools provided on Google’s website. One of the main features of this application will be using the smartphone’s camera to scan the barcode for our items. For this feature we will incorporate ZXing into our application. ZXing is an open-source multi-format 1D/2D barcode image processing library implemented in Java. This open-source library will help us capture an image of a barcode and export the data from the image to wherever we need to store it. The next feature of the application will involve creating a virtual cart for the user. This will display costs, number of items purchased, weights for items and total cost. The application will connect to a database that will keep records of all transactions on the application.


Figure_:_This_Use_Case_model_shows_interaction_phases_between_the_user,_the_mobile_application,_and_our_databases._It_shows_how_features_will_interact_with_our_modules_for_the_project.'>Figure: This Use Case model shows interaction phases between the user, the mobile application, and our databases. It shows how features will interact with our modules for the project.

Module 2: Scale

The scale will play a pivotal role in the system as it will provide an accurate measurement of the merchandise inside the cart. The scale will be using a load cell connected to an integrated circuit, and because the signal is only a few millivolts in amplitude it will have to be amplified before being read. The weight is then compared with 2 libraries, the first being a library of items with associated weights and then a library containing the list of products scanned by the consumer. A mockup of what it is being described can be found in the figure below however the Wheatstone bridge is representing the load cell that will be used. In our system the scale will be built into the base of the cart’s basket. It will give a measurement depending on whatever items are placed into the cart.


Figure: Schematic for the scale that will be used in the project (Created in Multisim)

Module 3: Microcontroller

Arduino Uno

In our project the Arduino Uno microcontroller will be used to provide scale readings and data transfers to our database. The Arduino Uno is a microcontroller board based on the ATmega328. It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz ceramic resonator, a USB connection, a power jack, an ICSP header, and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a USB cable or power it with a AC-to-DC adapter or battery to get started.

This is the latest revision of the basic Arduino USB board. It connects to the computer with a standard USB cable and contains everything else you need to program and use the board. It can be extended with a variety of shields: custom daughter-boards with specific features. It has a USB-to-serial chip the ATMega8U2, and newly designed labeling to make inputs and outputs easy to identify.




Operating Voltage


Input Voltage (recommended)


Input Voltage (limits)


Digital I/O Pins

14 (of which 6 provide PWM output)

Analog Input Pins


DC Current per I/O Pin

40 mA

DC Current for 3.3V Pin

50 mA

Flash Memory

32 KB (ATmega328) of which 0.5 KB used by bootloader


2 KB (ATmega328)


1 KB (ATmega328)

Clock Speed

16 MHz


The Arduino Uno in this project will be powered through a battery source. The adapter can be connected by plugging a 2.1mm center-positive plug into the board's power jack. Leads from a battery can be inserted in the Gnd and Vin pin headers of the POWER connector. The board can operate on an external supply of 6 to 20 volts. If supplied with less than 7V, however, the 5V pin may supply less than five volts and the board may be unstable. If using more than 12V, the voltage regulator may overheat and damage the board. The recommended range is 7 to 12 volts.


The ATmega328 has 32 KB (with 0.5 KB used for the bootloader). It also has 2 KB of SRAM and 1 KB of EEPROM (which can be read and written with the EEPROM library).

Input and Output

Each of the 14 digital pins on the Uno can be used as an input or output, using pinMode(), digitalWrite(), and digitalRead() functions. They operate at 5 volts. Each pin can provide or receive a maximum of 40 mA and has an internal pull-up resistor (disconnected by default) of 20-50 kOhms.


The Arduino Uno has a number of facilities for communicating with a computer, another Arduino, or other microcontrollers. The ATmega328 provides UART TTL (5V) serial communication, which is available on digital pins 0 (RX) and 1 (TX). An ATmega16U2 on the board channels this serial communication over USB and appears as a virtual com port to software on the computer. The '16U2 firmware uses the standard USB COM drivers, and no external driver is needed. The Arduino software includes a serial monitor which allows simple textual data to be sent to and from the Arduino board. The RX and TX LEDs on the board will flash when data is being transmitted via the USB-to-serial chip and USB connection to the computer (but not for serial communication on pins 0 and 1).

A SoftwareSerial library allows for serial communication on any of the Uno's digital pins.

The ATmega328 also supports I2C (TWI) and SPI communication. The Arduino software includes a Wire library to simplify use of the I2C bus; see the documentation for details. For SPI communication, use the SPI library.


The Arduino Uno can be programmed with downloaded Arduino software.

The ATmega328 on the Arduino Uno comes preburned with a bootloader that allows you to upload new code to it without the use of an external hardware programmer. It communicates using the original STK500 protocol using C header files.

Bootloader can be bypassed and the Arduino can be programmed through the microcontroller through the ICSP (In-Circuit Serial Programming) header.

Testing (Software)

Arduino Simulator benefits and features are:

  • The ability to teach and demonstrate the inner workings of an Arduino 

  • Test out a sketch without the hardware, or prior to purchasing hardware

  • Debug a sketch

  • Demonstrate a project to a potential customer

  • Develop a complicated sketch faster than using the hardware 
Automatic (Software) Reset 
Arduino Uno is designed in a way that allows it to be reset by software running on a connected computer. The Arduino software uses this capability to allow you to upload code by simply pressing the upload button in the Arduino environment. This means that the bootloader can have a shorter timeout, as the lowering of DTR can be well-coordinated with the start of the upload. 
Other implications are when the Uno is connected to either a computer running Mac OS X or Linux, it resets each time a connection is made to it from software (via USB). This feature is useful to help the unit maintain a clear memory condition which should minimize corrupt memory problems. It is also possible to disable the auto reset. 
USB Overcurrent Protection

The Arduino Uno has a resettable polyfuse that protects your computer's USB ports from shorts and overcurrent. Although most computers provide their own internal protection, the fuse provides an extra layer of protection. If more than 500 mA is applied to the USB port, the fuse will automatically break the connection until the short or overload is removed.

This feature isolates connected components which minimize the stray current that can contribute to the instability of legacy systems.

Module 4: Connectivity (Device data Transfers)
For this module we focus with the connections needed for each device to communicate. The conventional method would be a hard wire connection however realistically thinking we agreed that a consumer would not want to plug into a scale every time and so a WiFi shield is being implemented for communication between the scale and the Arduino Uno. The WiFi shield supports both types of wireless networks infrastructure (BSS) and ad-hoc (IBSS) and is also allowed to connect to secure networks (cryptographers and are supported 64 and 128-bit WEP, WPA/WPA2 and TKIP, AES and PSK). The interface between the scanner (phone) and the Arduino Uno will be hard wire most likely via universal serial bus. Below are pictures of the WiFi shield and USB that will be utilized for connectivity.

Figure: Concept 3D Model of Shopping Cart

Module 5: Database and GUI

For our project we will design two databases using SQL. This database will hold information on all items the scanner is compatible with. Information such as the name of the item, price, and weight will be available for the mobile application when it is requested. The second database will contain transactions created by the mobile application. This database will keep track of the amount of items, total costs, and total weights as well as weights calculated by the scale.

Our transaction database will be accessed by the GUI interface we will design for the Retailer. They will be able to extract a transaction and view all details to it. This GUI will also display if the items weight are matched to the scale’s reading. The GUI will be programmed as a web application for easy access on any operating system.

Linked List Program:
We will create a linked list software program to store data from the scanned items. The barcode from the scanned items will be cross referenced with the store database. When we scan an item it will decrement a counter in the database to keep track of the items put into the cart. For our project the most important field is the weight which will be checked at the checkout counter to confirm purchase weight.
Our linked list will be data structures which will include the 8 fields including;
Data Array with Purchase ID, Item Weight, Scan time, Stock ID, Barcode Number,

Name, Price, Supplier Code and a link to the next node in the list.

Our Store database will be a file to hold the information from the linked lists with 9

fields including:

Purchase ID, Total Weight, Item Weight, Stock ID, Barcode Number, Name, Price,

Number in Stock, Minimum Order, Quantity, Reorder Quantity, Supplier Code and a

pointer to the vector in a table.


Our Cart Database will be filled with the same data structures as our linked list and

include one more field called Total Weight.

Using the Purchase ID, the Checkout Scale and the Store database, the Cart Database

will be compared at the checkout to ensure that the weight total of items in the cart are



Figure: Mock GUI Sample on the Retailer end.

Work Plan:
1. Verifying Scale Circuits components

a. Verify steady input for normal scale reading.

b. Verify working components.

c. Verify operation will work against various weights.

2. Design and testing Scale circuit

a. Assemble circuit drawings for all modules.

b. Test each module with instrumentation ammeter/voltmeter.
3. Design and Code Smartphone Application

a. Verify features needed on application.

b. Design workflow and communications of application.

c. Implement scanning libraries to application.

d. Test application.
4. Design of Software and Database

a. Create database that will communicate with mobile application and Employee software.

b. Create Employee software to interact with database.

c. Test software.

5. Simulation

A. Verify desired operation of each circuit by simulating the hardware and test software.

B. Simulate all modules together by simulating the hardware and test software.
6. Prototyping

a. Assemble each module on a separate breadboard.

b. Test each module on the breadboard and compare with simulation behavior.

c. Assemble all modules together, test, and compare with simulation behavior.

7. Testing

a. Test with various weights and sales to verify working system.

8. Documentation

a. Finalize design.

b. Create installation manual.

c. Create user manual.

d. Testing and validation document.

e. Maintenance document.



Date to be completed

Verify Circuits


Design Circuit for Modules


Design Software For Modules






Testing and Validation




Finalizing and Preparing for Presentation


Table 1 – Milestone chart


The below chart is a ballpark figure of what is needed. The actual cost of materials will vary.



Price [$]

Arduino Uno Board



Wi-Fi shield






LCD Screen






Rechargable Batteries



Instumentation Amplifier



Misc Wiring/ Cables



Shopping Cart



Test Items






Table 2 - Budget chart


Qualifications of Team Members:

Richard Brito – Schematic and circuit analysis and design.

Aredious Brown – Circuit simulation and testing.

Jonathan Rivera – Java Programming, Database structure and circuit testing.

Download 70.23 Kb.

Share with your friends:

The database is protected by copyright © 2024
send message

    Main page