In Brief:
A wireless mass storage device with a fingerprint scanner for authorization, induction coil for wireless charging, and OLED screen for user feedback.
Summary:
Our team has constructed a fingerprint-authenticated wireless pen drive with an OLED display. To use the pen
drive, a user simply authenticates by placing his/her thumb on the fingerprint sensor, which causes the drive to
sync wirelessly to a home station. This station is connected to a PC over USB, and using our application-layer
software on PC, allows the user to read and store data on the device.
The base station also has an inductive charger that the user can place the device on to charge wirelessly,
without the hassle of plugging anything in. 20 fingerprints can be stored on the device, and each fingerprint
has a separate logical volume that the corresponding user can utilize as their own private storage space.
The device has a 1 inch OLED screen that gives the user feedback and information, such as which current user is
logged in, and how much storage is being used.
High Level Design
There are biometric solutions to data security, such as fingerprint-scanned, encrypted external disks, and
there exist devices that store data wirelessly. However, none of these devices combine the two functionalities
in any capacity. Our project aims to prove that a device that incorporates both wireless communication and data
confidentiality can be a convenient solution on a reasonable budget.
Wireless Communication: nRF24l01+ modules. Custom network stack for packet delivery. Library adapted from several
libraries found for Arduino. Network layer created for single-purpose.
Display: 1 inch OLED screen. Communicates over I2C. Adapted code from Adafruit driver for OLED display written
for Arduino, with regards to the OLED datasheet. Font from Bruce's thing.
Base Mat: Arduino Uno used as a serial passthrough device. Has an nRF24l01+ and a connection to the host computer
over USB COM serial. Simply passes data received on one end over to the other end. Includes an inductive charging
coil plugged into 12V wall wart.
Fingerprint Scanner: GT511C1R Library created from protocol documentation found online. Communicates over UART.
SD Card Reader/Writer: Simple SD Card breakout board. SD protocol is SPI. Protocol documentation and Arduino
SD Card library were helpful in creating PIC32 Library. Simple filesystem was created on top of SD layer.
The wireless communication is slow because much of the protocol is implemented in software. The nRF24l01+ supports
1Mbps hardware-streaming, but the protocol was too complicated to debug in a month's time, especially when also
writing all the other libraries.
Hardware Design:
The software for the device is mostly an application of the libraries we built.
It first initializes each onboard device, then begins the main program sequence. It prompts the
user for a fingerprint, and stays in a loop looking for a valid fingerprint until one is found.
Once a fingerprint match occurs, it logs the user into the device, displaying a welcome message.
If the user has a file in their sector of the filesystem, the system sends it over the nRF communication
channel, and enters the main remote command loop.
Upon receiving the command sync begin word ( 32 Bytes of 0xff... ), the pen drive begins listening for
a control word, which is either the ASCII letter 'x', for "Change user name," or 'y' for "Upload new file."
If the control word is not this value, the state machine reverts back to pending receipt of the sync word.
Actually issuing the commands is an application running on a PC, communicating over serial at 115200 baud
with an Arduino-design microprocessor with an nRF module. The Arduino is set up to simply pass the
information from one end to another; anything sent to it via serial gets sent out the nRF module, and
anything sent to its radio gets blasted out the serial.
The hardware details are all pretty simple. As discussed above, all modules connect using common peripheral
bus styles; UART, SPI, and I2C. Please see circuit diagram in appendices to see how it all goes together.
Design Results:
The primary measurement of success to verify our project was the fact that it could receive any arbitrary
file, write it to its disk, and then transmit it back after a power-down. We did not concern ourselves
very much with speed. The nRF line of modules has a proprietary mode called Shockburst, which theoretically
can sustain speeds of 1Mbps over SPI clocked at 5MHz. Since we already spent so much time adapting and
debugging the nRF library, and the only information on how to enable and use Shockburst was from the rather
lengthy and sometimes erroneous protocol manual, we decided that the speed we achieved with our synchronous
packet delivery system was adequate for our prototype. On our simple network stack, the device can support
840 Bytes per second transmission speed either way.
We never experienced any packet drop in transmission. The only cases where we encountered issues were in software,
where delays and other effects caused the nRF module not to be ready to receive packets that were in flight,
but those were fixed with careful debugging.
Although our device utilizes the very popular 2.4GHz band, the communication between nRF modules managed to
stay lossless throughout areas with very heavy Wi-Fi traffic.
The device is extremely usable. It does not require the nimble action of plugging in a device every time a
user wants to manipulate a file, rather it can be activated wirelessly. As well, there are no buttons on the
device except for a power switch, and the only actuation needed for operation is touching a finger to a fingerprint scanner.
The OLED is monochromatic, thus anyone with any sort of colorblindness will be able to use the device. The only possible restriction
is that if a user cannot use or manipulate a computer at all, they cannot utilize the device. As a Pen Drive, by its very nature it is
only useful when used with a computer, so this is not a very large concern.
IP Considerations:
Biometric-secured pen drives and wireless pen drives have been available on the market in recent years.
However in our patent search, none have combined the ease of use and security of both functionalities.
We could potentially patent our project. Although it is merely a prototype in its current state, it meets all
the functionality that we'd desire for drafting a patent. We would also like to
demo at BOOM next Fall.
We used existing open-source Arduino libraries as our reference for making the libraries for the nRF24l01+,
OLED, and SD Card PIC32MX libraries. See appendices below for links to the original libraries. The library
for the fingerprint scanner was made entirely by us from reading the protocol documentation given by the manufacturer.
The code running on the Arduino was made possible by heavily modifying a getting started example within ManiacBug's
nRF24l01+ library. This library was also used to interact with the nRF on Arduino. Their library proved to be a
very valuable asset in debugging as well. We left the credits to ManiacBug in the .ino file linked below.
The filesystem was developed purely by us, with some knowledge from OS classes.
Conclusion:
Our expectations were quite well met with this project. We sought out to do exactly what we accomplished:
make a functional proof-of-concept device with a very limited budget. Although we wish we had more time to
perfect it, we're quite proud of how far we've gotten. Some things that could be improved are:
Transmission speed. 840B/s would be fine for control logic, but ultimately this is a data-centered device.
Size. The device could very easily be scaled down to a rather small envelope, but as a prototype we needed
the 28-pin DIP variant of the PIC32MX for rapid prototyping and injection-programming. The other hardware as
well could be almost entirely integrated on a single PCB, including the nRF module and some sort of embedded
Flash memory. The battery, charging infrastructure, and OLED screen would potentially have to be raised away
from the board, but we believe it could fit in a similar form factor as a traditional pen drive.
Security. We do not encrypt any data stored on the drive. In the current version, this can be mitigated by
storing a file zipped with 7zip encryption or by storing a TrueCrypt disk image for the information the user
wants to store. However, we acknowledge that this would be much better if there was built-in hardware
acceleration for secure cryptographic algorithms to encrypt/decrypt each user's file. Doing encryption/decryption
on the PIC32 would have severely limited our throughput for transmission.
Filesystem. The filesystem in its current state cannot support folders or more than one file. As above, this
can be mitigated with an archive file of some type, but we would like to extend this in the future to follow
some well-defined filesystem's protocol, such as FAT32.
Regulatory Information:
From the FCC, unlicensed operators are allowed to transmit on:
902 to 928 MHz
2.400 to 2.4835 GHz
5.725 to 5.875 GHz
Our device operates within that 2.4GHz range, as is specified by the datasheet (see appendices).
The FCC also defines the maximum output power we can transmit to the antenna:
Maximum transmitter output power, fed into the antenna, is 30 dBm (1 watt).
Maximum Effective Isotropic Radiated Power (EIRP) is 36 dBm (4 watt).
The maximum power that our battery can even drain is less than the maximum transmitter output power.
Ethical Statement:
In accordance with the IEEE code of ethics, we have considered our design choices carefully. Our device
is made to ensure that nobody may be harmed during use. We accepted no briberies, as none were offered.
We encountered no conflicts of interest when creating our device. We make no claims that the device can do
something it cannot, nor is something that it is not. In writing this website, we support the growth of
intellectual understanding of technology, and hope that others will use insights we came to when creating
this device to help guide them through their design choices. Most of all, the device itself will not discriminate
based on any metric except for whether or not the person has fingers. The language used in the device's interactions
with the user was carefully chosen not to be hurtful or insulting.
Additionally, to you the reader, please verify our appendices for acknowledgement of sources, and let us know if
it is not to your satisfaction. We make no claims to code that is not ours, nor ideas.
Appendix I: Code Listing
Final Project Code:
config.h
filesystem.c
filesystem.h
final_project.c
fingerprint_sensor.c
fingerprint_sensor.h
fps.c
fps.h
glcdfont.c
nrf24l01.c
nrf24l01.h
oled.c
oled.h
Base Station Code:
autobuf.cpp
autobuf.h
base_station.cpp
win_serial.cpp
win_serial.h
NEW_NRF_PASSTHROUGH
printf.h
NEW_NRF_PASSTHROUGH.ino
Appendix II: Circuit Diagram
Appendix III: Cost Breakdown
| Component | Cost | Source |
|---|---|---|
| OLED display 0.96" (128x64) I2C, 3.3V | $4.79 | http://www.ebay.com/ |
| SD card reader | $0.99 | http://www.ebay.com/ |
| SD card, Kingston 8Gb | $3.92 | http://www.walmart.com/ |
| LiPoly battery, 3.7V, 1200mAh | $9.95 | https://www.adafruit.com/ |
| Inductive charger, 5V 500mA output | $9.95 | https://www.adafruit.com/ |
| 9V 1A power adapter | $2.39 | http://www.ebay.com/ |
| PowerBoost 500 LiPoly battery charger 5V output | $1.84 | http://www.ebay.com/ |
| NRF24L01 wireless transceiver, 3.3V, SPI (comes in pairs) | $1.99 | http://www.lightinthebox.com/ |
| Fingerprint scanner, 3.3V, TTL with cable | $34.95 | http://www.amazon.com/ |
| Arduino UNO-Based MCU (computer-facing side) | $4.82 | http://www.gearbest.com/ |
| Mini metal speaker 8ohm, 0.5W | $5.00 | on-hand |
| solder board | $1.00 | on-hand |
| push button | $0.10 | on-hand |
| Total: | $98.14 |
Appendix IV:
Nathan:
SW Debugging
Creation of Filesystem Library
Arduino Serial Passthrough Device + RF Protocol
Website
Z.:
SW Debugging
Porting Arduino Libraries
Package and Circuit Fabrication
References Used:
Data sheets:
NRF24L01: https://www.sparkfun.com/
Fingerprint Sensor:https://cdn.sparkfun.com/
Github Links:
OLED: https://github.com/adafruit/Adafruit_SSD1306
NRF24L01: https://github.com/maniacbug/RF24
SD: https://github.com/adafruit/SD