Friday, May 4, 2012

Final Project: InhaleSur Video

Final Project: Strengths and Weaknesses

The InhaleSur device described herein offers a unique opportunity to improve compliance in a market that is untapped; proactive inhaler protocol training occurs in physicians offices and pharmacies, but a thorough literature search uncovered no core technology that continually monitors inhaler usage throughout the entire course of treatment. InhaleSur will improve compliance with inhaler protocols first by ensuring that each canister is sufficiently shaken before inhalation of the medications within. Proof-of-concept for this device has been successfully demonstrated with a simple Arduino microcontroller that uses an accelerometer and a push button to detect the magnitude and frequency of device shaking; it also records when the canister has been compressed to alert the user when a refill is required. The accelerometer used for this proof-of-concept device can only measure tilt relative to gravitational forces rather than actual linear acceleration when transmitting data in real-time, and this is currently a device design weakness. Future work will incorporate a more sophisticated accelerometer into the design. Miniaturization of the device is also critical to ensure portability. The core strengths of InhaleSur are that it provides real-time feedback for the entire course of treatment for a patient suffering from asthma and removes the ambiguity associated with guessing whether or not the medication is sufficiently mixed. Additionally, knowing when to replace the medication canister reduces wasted drugs and ensures that patients are getting as effective a treatment as possible. Future design iterations will include the ability monitor the user’s force of inhalation as well as the ability to alert the user to the proper compression time of the canister. Commercialization designs of InhaleSur will also incorporate auditory alerts to these factors to make the device accessible to blind persons. InhaleSur will improve compliance with inhaler procedures and has the potential to dramatically impact the quality of life for asthma sufferers.

Final Project: Feature-Benefit Table

Feature	Benefit
Button	Each button press adds one “use” to a counter that tells the user how many uses are remaining and when a refill is required.
LCD Screen	The LCD screen is used to deliver messages to the user such as the number of uses remaining or an inhaler refill is required. In the future, the LCD screen could be replaced with an LED or a auditory alert to notify the user.
Accelerometer	Used to quantify shaking. Provides us with the tools to measure both the magnitude and frequency of shaking.
Portability	Competitive products (i.e. T-Haler) are intended for use in physicians’ offices or pharmacies. InhaleSur allows users to keep the device with them at all times.
Usage Tracking	This feature offers the user with a simple way to recognize when a refill is required instead of having to keep track with a calendar and simply guessing when the canister is empty. Avoids waste and ensures optimal dosage delivery.
Real-time Monitoring	This coincides with portability, but there is no guesswork or delay involved with using the InhaleSur product. Patients know exactly when their inhaler is sufficiently shaken.

Final Project: Proof-of-Concept Device

Device Description

The goal of InhaleSur is to deliver a reliable dose of bronchodilator by ensuring that the medication is sufficiently shaken prior to delivery. In order to do this, the device senses when the user has shaken the inhaler with enough acceleration and force over a period of six seconds. Once the shaking threshold is met, the device outputs a message on the liquid crystal display (LCD) telling the user that the inhaler is “ready to use.” With each compression of the inhaler, a button is triggered on the inside of the InhaleSur case. This button allows the device to keep track of the number of inhaler uses remaining before a medication refill is needed. The number of “uses remaining” is printed on the LCD screen. If the inhaler has zero uses remaining, an additional message is printed on the LCD screen saying “refill required.” InhaleSur is easy to use, provides key feedback to the user, and guarantees an adequately mixed dosage of medication.

Representative InhaleSure Device

Picture of circuit used on Arduino board

Device being shaken

Inhaler is sufficiently shaken

Device notifying the user how many uses remaining

Device notifying the user that refill is required

Final Project: Block Diagram

Block Diagram

The following diagram illustrates the hardware and software components of InhaleSur. The inputs for the device are the amount of shaking performed by the user and the button, which is used to determine when the canister has been compressed. The outputs for the device are the three displays on the LCD screen: “ready to use,” “uses remaining,” and “refill required.” When the inhaler is shaken with some quantifiable acceleration, the accelerometer measures this value in terms of x, y, and z components. The Arduino algorithm then determines whether any one of the x, y, or z acceleration values are greater than 800. The threshold of acceleration was set to 800 based on experimental testing which indicated that resting acceleration was around 400, while forceful shaking was around 800. The accelerometer outputs a value between 0 and 1023 corresponding to a voltage between 0 volts and 5 volts. Therefore, a threshold of acceleration of 800 corresponds to a voltage of 3.9 volts. Once the user has reached an x, y, or z acceleration greater than or equal to 800, the user than has 500 milliseconds to surpass the acceleration threshold again. The user must repeat this pattern 12 times, which correlates to a shaking time of 6 seconds. If the user does this in less than 500 milliseconds, the timer immediately restarts for the next 500 milliseconds interval. If the user does not meet the threshold 12 times consecutively, the algorithm restarts.

Once the threshold has been reached 12 times, the Arduino prints “ready to use” on the LCD screen. The user then compresses the inhaler canister once to deliver the medication. When compressed, the canister also compresses a button on the inside of the InhaleSur case. When the button is compressed, one “use” is subtracted from an internal counter, and then the remaining uses are printed on the LCD screen. If the number of uses remaining is equal to zero, the Arduino prints “refill required” on the LCD screen. The block diagram in Figure 1 also demonstrates the Arduino’s connection to a power source and to a computer via a USB connection.

Final Project: Specifications

Specification	Value, Value Range, or Quality Relating to Spec	Comments about rationale for specification
Battery life	4 months	Device needs to last the duration of use for the inhaler. Inhalers typically contain 200 dosages (Bailey, 2012). At minimum, 2 sprays per day is equivalent to a minimum battery life of 100 days. We added an additional safety margin to this value.
Button Sensitivity	Button must register only one “use” per canister compression	Button needs to count to relay reliable data about remaining medication to user
Shaking Voltage	Minimum thresholds to qualify as a sufficient shake in the x, y, and z directions is 800 units	The threshold of shaking was defined via experimental testing. Shaking with a voltage greater than 800 was classified as one successful shake. The accelerometer generates a number between 0 and 1023 corresponding to a voltage value between 0V and 5V, so the threshold of 800 corresponds to a voltage of 3.9V measured by the accelerometer.
Number of times shaking	Reach the voltage threshold 12 (each within 500 msec) times to qualify as sufficiently shaken	This is equivalent to six seconds of shaking; the minimum on official Instructions for Use for inhalers often states at least five seconds (PDR Network, 2011).

Final Project: Competitive Technologies and Reverse Engineering

T-Haler: A competitive technology and its design

Within the asthma market, it is expected that doctors and pharmacies offer patients a training session upon prescribing or distributing an inhaler for treatment (Kamps, 2000). This type of training must be viewed as the current market incumbent that would compete with InhaleSur in the market. Cambridge Consultants, a technology design and development firm, has created an asthma inhaler training device called the “T-Haler.” Cambridge Consultants "develops breakthrough products, creates and licenses intellectual property, and provides business consultancy in technology critical issues for clients worldwide (Cambridge Consultants, 2012). The product is an interactive training “game” that wirelessly monitors whether the patient has shaken the inhaler, the force with which they breathed in, and when the canister is pressed down to release the drug (Cambridge Consultants, 2012). The T-haler uses a unique combination of sensors and wireless transmitting technology to function. This technology was just released in March 2012; it is not yet officially on the market for sale. As such, no public list price is available. The website for the product promotes that the T-Haler doubles the compliance rates for inhaler protocol use.

REVERSE ENGINEERING ADVANTAGES AND DISADVANTAGES

When entering a market, one must consider the advantages and disadvantages competitor products offer. The T-Haler offers an advantage compared to doctors and pharmacies that provide inhaler training through staff personnel because the T-Haler minimizes the time and resources required by employees to individually train each patient. However, this tool is only a training device and is intended for use as a tool in doctors’ offices, pharmacies, and clinics. The T-Haler is at a disadvantage compared to InhaleSur because InhaleSur is designed to stay with the patient over the entire course of treatment, not just an initial training period. InhaleSur is available for at home use. Additionally, while the T-Haler currently provides feedback on other factors of inhaler protocol, there is no reason why future iterations of InhaleSur could not alert the user in real-time to other factors like inhalation force (with a simple gas pressure sensor) or the time the canister is compressed. Proof-of-concept of the shaking feature demonstrates that these elements can be monitored on a simple microcontroller device, so InhaleSur will be able to successfully compete in the asthma inhaler market space. The blog posts will provide a detailed explanation of InhaleSur’s functionality.

Final Project: Need for Device and Desired Outcome

Both asthma controller medication and quick relief medication treatments mentioned above commonly deliver therapeutic agents through an inhaler device. Inhalers are simple medical devices that release a mist of medication into the airways and lungs when a pressurized canister is compressed. Inhalers have a very specific set of instructions that must be followed in order for the medication to be most effective. However, a study published in the Journal of Pediatric Pulmonology showed that only 29% of children who had been trained using an inhaler performed all essential steps correctly, compared to 79% who had received comprehensive inhalation instructions in addition to follow-up technique checks at a pharmacy or in a clinical trial (Kamps, 2000). Other reports show that up to 90% of adults use incorrect techniques with their inhalers (National Asthma Council Australia, 2008). Proper inhalation techniques could avoid up to 75% of hospital admissions resulting from asthma attacks (Cambridge Consultants, 2012). One of the key steps for proper inhaler technique is shaking the inhaler for a minimum of five seconds prior to use. Dr. Howard Panitch, a Pediatric Pulmonologist at the University of Pennsylvania Hospital System, stated that one minute of device shaking would be ideal (Panitch, personal communication, April 3, 2012). While the literature suggests that inhaler training is not fully effective at ensuring procedure compliance to ensure that users get the most optimal dosage, current technologies on the market focus on better training tools to teach patients how to use their inhalers. A novel medical device that tells the user when the medication is sufficiently shaken is desired in order to deliver the most reliable dose. InhaleSur monitors the magnitude and frequency of shaking in order to tell the patient when the asthma inhaler is sufficiently shaken before inhalation.

Final Project: Target Population

Asthma is a chronic respiratory disease that affects an estimated 18.7 million adults and 7.0 million children in the United States alone (CDC, 2012). Asthma is caused by airway inflammation and a narrowing of the airways that leads to shortness of breath, coughing, wheezing, and chest pain. While asthma cannot be prevented, its symptoms can be controlled. There are two key types of asthma treatment medication; one is referred to as “controller medication” and the other is referred to as “quick relief medication” (WedMD, 2012). Controller medication uses corticosteroids as an anti-inflammatory agent to reduce swelling and mucus production in the airways. Quick relief medication, also known as rescue medication, uses short-acting beta-agonists (bronchodilators) to relax the muscles that tighten around the airways during an acute attack. Even with available treatments, the prevalence of asthma continues to increase in the population. The Centers for Disease Control reports that in 2009, 4.2% of the population had at least one asthma attack; this is equivalent to 8.7 million adults and 4.0 million children (Akinbami, 2011). Of those people already diagnosed with asthma, 52% had a severe attack in 2009 (Akinbami, 2011). The market to improve and design novel asthma interventional products is huge. Innovation for the asthma population will improve the quality of care and quality of life for patients, and there is an enormous business opportunity within this target population.

Here are the references for the Final Project Blog posts:

References

Akinbami, L. J., Moorman, J. E., & Liu, X. (2011, January). Asthma prevalence, health care use, and mortality: United States, 2005-2009 (Rep. No. 32). Hyattsville, MD: U.S. Department of Health and Human Services.

Bailey, W. (2012). Asthma inhaler overview. http://www.uptodate.com/contents/patient-information-asthma-inhaler-techniques-in-adults-beyond-the-basics

Cambridge Consultants. (2012). New asthma training device more than doubles proper use rates. Retrieved April 14, 2012, from http://www.cambridgeconsultants.com/‌news_pr319.html

CDC. (2012). Asthma: Data for the U.S. Retrieved from http://www.cdc.gov/‌nchs/‌fastats/‌asthma.htm

Granata, A. (Interviewer) & Panitch, Howard (M.D). (Interviewee). Attending pulmonolgist;Director, Pulmonary Medicine Fellowship Program. April 11, 2012.

Kamps, A. W., van Ewijk, B., Roorda, R. J., & Brand, P. (2000). Poor inhalation technique, even after inhalation instructions, in children with asthma. Journal of Pediatric Pulmonology, 29, 39-42.

National Asthma Council Australia. (2008). Inhaler technique in adults with asthma or COPD [Pamphlet]. South Melburne, VC, Australia: National Asthma Council Australia Ltd.

PDR Network. (2011). Advair HFA. Retrieved from http://www.pdrhealth.com/drugs/advair-hfa

WebMD. (2012). Asthma medications. Retrieved from http://www.webmd.com/‌asthma/‌guide/‌asthma-medications

Tuesday, April 17, 2012

Final Project: Prior Iterations of the Code

Rev 3: This code attempts to separate the force of shaking into a soft, medium, and hard range.

#include
LiquidCrystal lcd(12,11,13,10,9,8);
int buttonpin = 4;
int buttonstate;
int uses = 20; //Literature search for the average number of uses per inhaler
const int groundpin = 14;
const int powerpin = 18;
const int ypin = 2; //changed inputs for x, y, and z because of newer software (it splits it directly with analogRead)
const int xpin = 3;
const int zpin = 1;
int yaccel;
int xaccel;
int zaccel;
int VecSum;
int force;
int FTvariable;
int time = 0;
int LEDpin;
int HardShakeCounter;
int SoftShakeCounter;

//play with these numbers
int mass = 5; // mass of the standard arduino
int LowThreshold = 597; //added this so its easier to change
int UpperThreshold = 1000; //

void setup(){
pinMode(groundpin, OUTPUT);
pinMode(powerpin, OUTPUT);
digitalWrite(groundpin, LOW);
digitalWrite(powerpin, HIGH);
LEDpin = 9;
pinMode(LEDpin, OUTPUT);
lcd.begin(16,2);
pinMode(buttonpin, INPUT);
Serial.begin(9600);
}

//PUSH A BUTTON FIRST THAT SAYS "START SHAKING"
//press button, make sure counters are set to 0)

void loop(){
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);

if (zaccel < 900 && zaccel > 800)
{
HardShakeCounter++;
while (zaccel >500)
zaccel=analogRead(zpin); //keep reading until
Serial.print("Number of Hard Shakes = ");
Serial.println(

HardShakeCounter);
}

else if (zaccel > 500 && zaccel < 700);
{
SoftShakeCounter++;
while (zaccel >500)
zaccel=analogRead(zpin);
Serial.print("Number of soft shakes = ");
Serial.println(SoftShakeCounter);
}
}

----
Ammended Code Rev 2:

#include
LiquidCrystal lcd(12,11,13,10,9,8);
int buttonpin = 4;
int buttonstate;
int uses = 20; //Literature search for the average number of uses per inhaler
const int groundpin = 14;
const int powerpin = 18;
const int ypin = 2; //changed inputs for x, y, and z because of newer software (it splits it directly with analogRead)
const int xpin = 3;
const int zpin = 1;
int yaccel;
int xaccel;
int zaccel;
int VecSum;
int force;
int FTvariable;
int time = 0;
int LEDpin;

//play with these numbers
int mass = 5; // mass of the standard arduino
int LowThreshold = 597; //added this so its easier to change
int UpperThreshold = 1000; //

void setup(){
pinMode(groundpin, OUTPUT);
pinMode(powerpin, OUTPUT);
digitalWrite(groundpin, LOW);
digitalWrite(powerpin, HIGH);
LEDpin = 9;
pinMode(LEDpin, OUTPUT);
lcd.begin(16,2);
pinMode(buttonpin, INPUT);
Serial.begin(9600);
}

void loop(){
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);
VecSum = sqrt((xpin)^2+(ypin)^2+(zpin)^

2);
force = (VecSum*mass);
FTvariable = (force*time);

Serial.println(FTvariable);

if (VecSum > LowThreshold) //1st threshold is the zero state --> change this to a button to start time.
{
time = millis();
}

while (FTvariable >= UpperThreshold)//find how much shaking over how much time you need to be fully mixed
{
uses=uses-1;
if (uses == 0)
{
lcd.print("Refill Required");
}
digitalWrite(LEDpin, HIGH);
delay(5000);
digitalWrite(LEDpin, LOW);
FTvariable = 0;
}
}

----

Revision 1:

/* read the amount of shaking

determine the force exherted, F=ma

count the time of shaking

when the force * time hits a certain threshold, turn on the led

count the number of button pushes

print the number of uses left

when the number of uses equals zero, print "refill needed"

--to be sufficiently mixed, F*time = x, use x as threshold

--also must use x,y,z direction, so take the vector sum to get the overall force

--time should start counting when above another total acceleration threshold

#include

LiquidCrystal lcd(12,11,13,10,9,8);

int buttonpin = 4;

int buttonstate;

int uses = ????;

const int groundpin = 14;

const int powerpin = 18;

const int ypin = 16;

const int xpin = 15;

const int zpin = 17;

int yaccel;

int xaccel;

int zaccel;

int VecSum;

int force;

int mass = ???;

int FTvariable;

int time = 0;

int LEDpin;

void setup(){

pinMode(groundpin, OUTPUT);

pinMode(powerpin, OUTPUT);

digitalWrite(groundpin, LOW);

digitalWrite(powerpin, HIGH);

LEDpin = 9;

pinMode(LEDpin, OUTPUT);

lcd.begin(16,2);

pinMode(buttonpin, INPUT);

Serial.begin(9600);

}

void loop(){

yvalue=analogRead(ypin);

xvalue=analogRead(xpin);

zvalue=analogRead(zpin);

VecSum = sqrt((xpin)^2+(ypin)^2+(zpin)^2);

force = (VecSum*mass);

FTvariable = (force*time);

if (VecSum > 1st THRESHOLD)

{

time = millis();

}

while (FTvariable >= UPPER THRESHOLD)

{

uses=uses-1;

if (uses == 0)

{

lcd.print("Refill Required");

}

digitalWrite(LEDpin, HIGH);

delay(5000);

digitalWrite(LEDpin, LOW);

FTvariable = 0;

}

Final Project: Asthma Device Code

Here is the FINAL CODE for InhaleSur:

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,13,10,9,8);

int buttonpin = 4;
int buttonstate;
int uses = 3; //Literature search for the average number of uses per inhaler

const int groundpin = 14;
const int powerpin = 18;
const int ypin = 2;
const int xpin = 3;
const int zpin = 1;
double yaccel;
double xaccel;
double zaccel;
double VecSum;
double total_VecSum;
int newtime=0;
int newesttime=0;
int counts=0;
int counting = 0;

void setup(){
pinMode(groundpin, OUTPUT);
pinMode(powerpin, OUTPUT);
pinMode(buttonpin, INPUT);
digitalWrite(groundpin, LOW);
digitalWrite(powerpin, HIGH);
lcd.begin(16,2); //inserted
Serial.begin(9600);
}

void loop(){
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);
newesttime++;
delay(2);

if (!counting && xaccel>800 || yaccel>800 || zaccel>800)
{
   newesttime = 0;
   counting = 1;
}
if (counting && newesttime<500 && xaccel>800 || yaccel>800 || zaccel>800)
{
   newesttime=0;
   while (xaccel>800 || yaccel>800 || zaccel>800)
   {
     yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
    xaccel=analogRead(xpin);
    zaccel=analogRead(zpin);
   }
   counts++;
Serial.println(counts);

}
else if (counting && newesttime>=500)
{
   counting = 0;
   counts=0;
   Serial.println(counts);
}

if (counts>=12)
{
Serial.println("Ready to use!");
lcd.print("Ready to use!");
delay(3000);
lcd.clear(); //alysa added this
counts=0; //added this
lcd.setCursor(0,0);
}

buttonstate = digitalRead(buttonpin);
if (buttonstate==0)
{
    uses=uses-1;
    delay(200);
    lcd.print(uses);
    lcd.println(" uses remaining      ");
    delay(5000);
    lcd.clear();

if (uses == 0)
    {
      lcd.print("Refill Required");
      lcd.setCursor(0,0);
    }
}

}

The following is the final draft of the code for our asthma inhaler device.
------------
const int groundpin = 14;
const int powerpin = 18;
const int ypin = 2;
const int xpin = 3;
const int zpin = 1;
double yaccel;
double xaccel;
double zaccel;
double VecSum;
double total_VecSum;
int newtime=0;
int newesttime=0;
int counts=0;
int counting = 0;

void setup(){
pinMode(groundpin, OUTPUT);
pinMode(powerpin, OUTPUT);
digitalWrite(groundpin, LOW);
digitalWrite(powerpin, HIGH);
Serial.begin(9600);
}

void loop(){
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);
newesttime++;
delay(2);

if (!counting && xaccel>800 || yaccel>800 || zaccel>800)
{
newesttime = 0;
counting = 1;
}
if (counting && newesttime<500 && xaccel>800 || yaccel>800 || zaccel>800)
{
newesttime=0;
while (xaccel>800 || yaccel>800 || zaccel>800)
{
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);
}
counts++;
Serial.println(counts);

}
else if (counting && newesttime>=500)
{
counting = 0;
counts=0;
Serial.println(counts);
}

if (counts>=12)
{
Serial.println("Shaken");
}
}

/* while (newtime < 5000)
{
yaccel=analogRead(ypin); //changed these from yvalue to yaccel (just to match inputs above)
xaccel=analogRead(xpin);
zaccel=analogRead(zpin);
VecSum = sqrt((xaccel*xaccel)+(yaccel*yaccel)+(zaccel*zaccel));
total_VecSum=total_VecSum+VecSum;
delay(100);
newtime=newtime+100;
}

Serial.println(total_VecSum);
}
*/

//down increases (700) up decreases

/*break it down to categories - light, light medium , medium, hard
if acceleration value is between here and here, then build conditions for each of the shakes
assign a value to each of the shakes*/