artificial-unintelligence_TriageID

Patient Wristband
Secure Reader Hub
Wristband and Hub
Inside of Hub
Login Page
Wristband Tap Page
Patient Information Summary and AI-Powered Statistics
Full Patient Information Page
Add/Edit Patient Form
Add/Edit Patient Form
Add/Edit Patient Form
NFC Scanner Explosion Render
NFC Scanner Explosion Render v2
Bracelet Explosion Render
Logo

Inspiration

370,000 emergency department patients experience serious harm from diagnostic errors every year (Source: Newman-Toker et al., 2022). The initial decisions that EMTs, nurses, and doctors make early on can be as serious as life-or-death for these patients (Source: Wessman et al., 2021). Often, EMTs are not equipped with enough initial information on the patient, leading them to having to diagnose the patient on the spot. This leads to biases and errors in the medical process, which results in patient harm. A close relative of one of our teammates died in the emergency department due to doctors not having enough preliminary information on the patient, resulting in a severe misdiagnosis.

As a solution, we thought that it would be helpful to create a system that allows EMTs and nurses to get quick summary information for already at-risk individuals during this initial triage process, so that EMTs, nurses, and doctors could get ready and rapid access to this information and prevent these serious harms to patients in the EMT.

What it does

TriageID is a medical emergency information system that shows EMTS and emergency medical staff key patient information as well as AI-powered insights with a single touch of an NFC bracelet. Such medical staff can range from doctors to emergency respondents with the common goal of providing them with curated information to eliminate the need of on-site rediagnoses. This is accomplished through an NFC module within the bracelet which when scanned across a hub, securely retrieves critical patient information and quickly-calculates a few AI-powered insights that help ENT's and nurses improve diagnosing processes in emergency rooms.

This patient information is initially added through the doctor’s web portal on the TriageID site, where each patient is then given a unique NFC containing bracelet. A risk factor score is also provided through a medically specialized AI model with calculation based on provided data.

How we built it

The physical NFC scanner box was built on an Arduino Nano microcontroller, with a PN532 NFC Module for the NFC capabilities, a 16x2 LCD screen, and an active buzzer for feedback and user-friendliness. It was then enclosed in a 3D-printed enclosure to make the design sleek and compact.

The bracelet demo was build using a 3D-Printed case with an NFC chip module inside, which could be reprogrammed for the purposes of displaying that the demo works.

The backend of the app is build on a Django API, using two different apps for the doctor user accounts and for the NFC users. This ensures that both remain encapsulated from each other for security reasons. Within Django, the data associated with each NFC-tag ID is stored in heavily-encrypted NFC tables, to prevent users from viewing the data as plain-text (as medical data should be kept private and safe).

Within the backend, the AI summary uses a free AI model API called ArkLabs with a prompt to run the app (for the purposes of displaying the proof-of-concept of the product). The "seriousness score" uses a skikit-learn regression model (trained on a wide diabetic-patient severity dataset) with additional mathematical abstraction functions on top of it to adjust the scores to fit a wider audience of data.

Logically, the NFC tag contains a 15-character "User ID", which identifies the patient. Due to security concerns, the NFC tag only contains this "User ID", but not any patient information just in case the tag is lost. The Django backend models map each "User ID" to a specific patient's information, that can only be accessed by physically tapping the NFC tag on a reader and then attempting to access the "User ID" in the SQL table that way.

When accessing patient data from /dashboard, the user initially connects the secure NFC scanner module to a serial port, and then connects to the serial port by using their browser. Upon connecting, the serial port is saved to the user's cookies so that they do not have to worry about conecting to the same serial port again. Then, it consistenly reads the serial port data at a baud rate of 115200, and when the tag is tapped on the module it prints the "User ID" stored on the NFC tag to the computer's serial output, which the dashboard processes to retrieve Patient Information and AI statistics from the Django API and the respective AI models and APIs as well. It retrieves the Patient Information almost instantaneously and displays that, so that the EMTs do not have to wait as the scikit-learn model and the ArkLabs API take 5-10 seconds to respond.

The "User ID" NFC read/write firmware for the NFC Scanner is written using Arduino IDE, using C++.

Challenges we ran into

Wiring management within the NFC hub - During the construction of the NFC hub which consisted of the Arduino, NFC reader, and LCD display, initially the wiring inside the box was very unstable. However with the addition of a NFC module holder and a little bit of duct tape magic, the insides of our box became better organized.

3D Printer Loss - We lost our printer, as the extruder broke midway through a print. Due to this, we had to rush during the middle of the competition to find individuals who owned 3D printers and could help us. This is due to the fact that none of our team was certified for the Elko Engineering Garage, so this caused us a lot of worry and hassle.

AI Model Training - When initially training the model, it did not seem to work well. However, when we added the mathematical abstraction functions to the scikit-learn model, it worked surprisingly well with just a few mathematical tweaks.

3D Printing Tolerance - The wristband print needed to be as small as possible to still fit comfortably on the wrist while holding the NFC tag which required multiple prints and tries as even millimeter differences caused the print to become unusable.

AI Model Integration - For some reason, despite the team having plenty of experience in API integrations, the AI model would keep throwing random HTTP errors, such as 403, 402, 500, etc. Even if the code worked in some files, it did not work in others. Ultimately, we replicated a stack overflow post that we found that vaguely covered the subject and it worked perfectly.

3D Design Negligence - We forgot to add a USB-C port into the 3D print for the NFC Scanner Case. In order to prevent wasting too much material after having attempted to print multiple times, we just drilled a hole into the side of the box in the right spot and it worked perfectly.

Pitch Deck Render Issues - When rendering the assets for our pitch deck, unfortunately none of our laptops were powerful enough to run the render software in enough time (the estimated time was shown to be around 2 days). Therefore, one of our teammates decided to drive all the way back home to use their much more powerful home PC to render the software faster, in just a few minutes.

Accomplishments that we're proud of

We are proud that we were able to integrate technologies and skills that are difficult to tackle individually (such as Artificial Intelligence Models, Hardware, CAD Modelling, and Software-Hardware integration) and combined it all into a great project that has a real-world impact.

We are also proud of the fact that we were able to output so much more than we ever thought we would be able to, as we created a truly worthwhile project that is well-designed with the user in mind, whilst taking care of patient data security and solving a very real problem that one of us had to deal with in real life. An insane amount of work went into developing Triage ID, and we are all proud of each other for giving this hackathon their absolute best.

We are also extremely proud of the fact that we were able to tackle a real-world problem that one of our teammates directly witnessed through the hands of a relative and were able to dedicate this project to them.

What we learned

Firstly, we learned how to integrate hardware and software together effectively through serial inputs. Then, we learned how to add to models manually through mathematical abstraction, and that was a very useful skill to learn for AI applications into the future. We also learned how to CAD-model effectively in order to design proper and well-fitted parts for our projects.

Ultimately, we learned that no matter what problems we face as a team, if we have a solid idea we will ultimately persevere.

What's next for TriageID

Here are a list of just a few of the many things that we wish to integrate into TriageID after the hackathon, based on feedback from doctors and other medical professionals:

Offloading our current model API onto a private server running a local instance of an LLM, for health security reasons (this should be done anyways, but in this demo the API is used as a proof of concept)
Integration with Apple Watch/WearOS for Android, as they contain NFC capabilities as well
Integration with NetCare (the current Alberta Health management platform)
Allowing doctors to assign multiple NFC-bracelets to patients, in case a patient loses one