Thermistor Respiratory Monitor

Use of device

Project overview

Motivation

For our project, we wanted to create a solution to a real-world problem. Many biomedical devices, such as commercially available respiratory monitors, are designed for the developed world and require a stable power-supply to operate. We wanted to implement a solution that is adaptable to different environments.

Our device uses several concepts we learned not only this semester in ECE 4760, but also in other classes at Cornell. We use analog-to-digital conversions to sample readings from both the thermistor and the battery, pulse-width modulation to generate a signal for the speaker, and timers to switch between tasks. Our implentation also includes various analog circuitry for voltage regulation and signal amplification. Developing a robust and accurate respiratory monitor served to be a challenging, yet rewarding experience.

Previous Work

When doing research for this project, we came across several respiratory monitors using different sensors for measuring breathing. Other methods of monitoring respiratory rate include a chest force sensor (to detect force produced by chest movement), impedance pneumograph (which uses skin electrodes to calculate transthoracic impedance), and pulse oximetry (which measures O2 saturation in blood). While commercial devices to monitor respiratory rate exist, they use motion or force sensors to determine respiration rate. These monitors tend to be better suited for developed countries where a stable power supply is not a concern. We want to design our device geared to the needs of undeveloped areas. Therefore, we aimed for our thermistor monitor to be comparatively cheaper, easier to use, as well as reliable.

We also discovered another thermistor respiratory monitor research project. The design of the device differed from ours, in that it included two thermisors; one that remains in the outside environment for reference and one that goes inside the nostril.

High-Level Block Diagram

1. Thermistor Measurements

The resistance over the thermistor drops when its surrounding temperature increases, and goes back down when the temperature decreases. The voltage also, accordingly drops when a person exhales and rises when a person inhales. We use an operational amplifier to make the changes in temperature more apparent. The output of the amplifier is read into the microcontroller's ADC channel 0.

2. Voltage Measurements

Under battery operation, our device takes a voltage sample across the battery about every minute. Since our device uses a 9V battery, a voltage divider is used to drop the voltage so that it is about 2.2V at PINA1 (ADC channel 1).

3. Power

Our device can be powered through either a standard AC power suppy or a single 9V battery.

4. Turn On Display

To conserve power, the user must hold down a button to turn on the display to read the respiration rate. This prevents the user from leaving the display on by mistake and draining the battery.

5. Output Sound

There are two different alarms for our device generated by a piezoelectric speaker. The first is higher in pitch and alarms if the patient is not breathing. The second is a signal that the device is running on low battery. While the first alarm is a continous sound, the low-battery alert is a one second long tone.

6. Respiration Rate Display

Breathing rate is measured and displayed in breaths/min on an LCD. This allows whoever is monitoring the patient to see if the patient is breathing too fast or too slowly.

7. Measurement

This task does the actual calculation of the respiration rate using samples from ADC0.

Design Decisions

Microcontroller

When choosing a microcontroller for this project, we first wanted to find the smallest microcontroller possible so that it could be mounted right onto the device's mask. However, when identifying how many I/O ports and ADC channels would be neccessary for our project, we realized that the AtMega1284p microcontroller that we had been using all semester would be ideal.

Thermistor

During the initial stages of our project design we experimented with several thermistors and their placement on the device. Since a drastic temperature difference is not produced when a human breathes, we needed the smallest, and therefore most sensitive thermistor we could find. Larger thermistors we experimented with either could not detect a "breath" or had a very slow response time. We also thought a mask around the patient's nose and mouth would be the least intrusive placement of the thermistor.

Display

Because we wanted to design our device to be low-powered, choosing the right display for the respiratory rate was a concern. Orignally, we planned to use two 7-segment displays which turned on when the user pressed a button. However, we decided to use an LCD screen for a nicer display. In order to reduce power usage, the LCD only receives power when the user presses the display button, which reduces the load on the battery.

Standards

As a medical device, this respiratory monitor must meet regulatory requirements outlined by governments. This includes meeting HIPPA standards which protects individuals� medical records and other personal health information, including respiration rate. However, since we are not planning to store this information, this regulation should not be an issue. Before it can be sold commercially in the United States, the device would also need FDA approval.

Software Design & Implementation

Software Overview

The C programming language was used to program the MCU using the AVR Studio version 4.15 and was compiled using the WINAVR GCC C compiler. The software for the respiratory monitor contains 5 different tasks and 2 interrupt service routines (ISR). The first ISR is the Timer0 Compare Match Vector. This ISR activates every 16.4 ms and decrements three different timeout counters whenever it activates. It also zeroes the variable count (used to measure respiration rate) to prevent it from overflowing. Since the clock of the MCU is 16 MHz, we set the prescaler to 1024 and OCR0A to 255. Setting OCR0A to 255 means the ISR will activate every 256 clk cycles. The second ISR used was the AC ISR. This ISR activates when the onboard AC outputs a 1. This ISR was used to measure the respiration rate of the person. This will be described in detail below in the appropriate section.

Main

The main function initializes the device and then goes into the main loop. Both the low pass and high pass filters have very large time constants (22 seconds) and capacitors. This means that they will take an extremely long time to charge before the overall device can begin to work. This start up time was on the order of minutes, which was too long in our opinion. To solve this problem we created a separate circuit that would charge our capacitors using much smaller time constants. This was done in the first 10 lines of code in main before any other function was initialized. First, PinB5 and B4 are set to output. B5 is set to 0 V and B4 is set to 5 V. This essentially turns on the Vcc and ground for the charging capacitor circuit. The charging capacitor circuit is left on for 5 seconds before it is turned off. It is turned off by switching B4 and B5 to inputs. Afterwards the initialize functions are turned on and the while(1) loop begins.

The while-loop goes through a series of conditions to see if the device needs to call one of the tasks. The thermistor and sampling tasks are both timed, so if either timer count equals 0, the counter is reset and the task is called. The thermistor sampling task is called every second, while the battery sampling task is called every minute. The measure task is called when the measure_flag indicates that a measurement is ready to be taken. Lastly, the display task activates when the user holds down the display button.

Thermistor Sampling

Samples from the thermistor are taken through PINA0. First, the ADMUX register is set to turn on the left adjust result and external reference. The MCU then waits for a conversion to occur, and then sets the variable sample_old to the current sample and the sample variable to the high bits from the ADC. The absolute value of the difference between sample_old and sample is used to determine if the patient has stopped breathing. If this difference is less than or equal to 8, then this is considered a "no breath". If the MCU detects 10 consecutive "no breaths", a PWM signal is generated to produce a sound from the speaker. If the difference is above the tolerance, then the "no breath" counter variable c is reset to 0 and the PWM signal is set to be turned off.

The tolerance for the difference between breaths was found through experimentation. Looking at the ADC values on the UART, the range of the sampled values was 6-8 when a person was not breathing. To compensate for this fluctation, we compare the difference between consecutive thermistor samples against 8 instead of 0. We also decided to have a counter to keep track of the number of "no breaths" detected because depending on how a person is breathing, consecutive samples could fall into the tolerance range. Counting up to 10 consecutive "no breaths" drastically reduces the number of false positive alarms.

ADC sampling and PWM signal generation were concepts we learned earlier in the semester in Labs 2 and 3.

Battery Sampling

To take a sample from the battery, ADC channel 1 on PINA1 is turned on by setting the ADMUX register. The MCU waits for a conversion to occur and then sets the variable bat_samp to the high bits from the ADC. The sample is then compared to the ADC value that was found to correspond to a voltage of 7.6 V. During testing it was found that device operation becomes unstable at 7.5 V. Therefore, we decided to warn the user when the voltage of the battery becomes 7.6 V

If the battery sample is found to be less than or equal to the tolerance, then a PWM signal is generated, left on for about 1 second, and then is turned off. The PWM channel which produces a tone for a low-battery warning has a larger prescalar than the PWM channel to produce the alarm for when a patient is not breathing, making the low-battery tone lower in pitch.

Measuring Task

The respiratory rate is measured by using the AC and measuring the time difference between when the voltage across the thermistor crosses the reference voltage. The first part of this is done in the ISR. When the voltage across the thermistor crosses the reference voltage the AC ISR activates. It then stores the number of clk cycles into the variable tau2 and stores the number of clk cycles of the previous crossing in tau1. The difference between tau2 and tau1 is then stored in the variable period. In essence this ISR measures the difference in the number of clk cycles between two reference voltage crossings. Once this measurement is done the measure flag is set and the measure task is activated. In the measure task an average difference in clk cycles is calculated by doing a weighted average between the newly measured difference in clk cycles and the previous average difference in clk cycles. The weights are 0.75 of the previous average and 0.25 of the new difference. This weighted average is taken so that an average respiratory rate can be calculated. This average difference in clk cycles is then converted to respiratory rate in breaths per a min (bpm). This is done by converting the difference in clk cycles to minutes and taking the reciprocal. We take the reciprocal because the AC ISR is activated every breath, i.e. it measures the time for one breath.

While writing this code we ran into the problem that the AC ISR was activating several times per one crossing. This was happening because as our signal crossed the reference voltage the noise in our system caused the signal to cross the reference voltage several more times. To solve this when the AC ISR is activated the first time the first line in the ISR turns off the AC ISR and the flag called flag is set. Then in main there is an if statement that says if flag is set to 1, wait 10 ms, turn on the AC ISR and reset flag. The 10 ms delay is used to wait for our signal to cross the reference voltage far enough so that there is no interference from the noise.

Display Task

The display function is used to display the respiratory rate on the LCD when the user is holding down the LCD push button. This was achieved by having the display function activate when PinB1 was read as 1. When PinB1 is 1 the LCD is initialized and the value of the respiratory rate stored in the variable breathrate and written to the LCD buffer. This value was then displayed on the LCD.

Hardware Design & Implementation

1. Thermistor Measurement

We used a thermistor based measuring system to measure the breathing rate of the patients. The thermistor is mounted inside a mask which is worn by the patient. The mask is a standard nebulizer mask that is used by asthma patients. The thermistor is mounted inside the mask so that it is directly in front of the patient�s mouth. As the patient breaths the hot air from the patient�s breath changes the resistance (Rth) of the thermistor. As a result, the voltage across the thermistor (Vth) will also change proportionally to how the patient breaths. We can therefore use Vth as an indirect measurement of how the patient is breathing. To measure Vth we used a voltage divider as shown below in Figure 1.

When the thermistor is at room temperature its resistance is approximately 1.2 kΩ so we choose R1 to be 1 kΩ. This was chosen so that Vth would be about 2.5 V if no one was breathing on the thermistor. We wanted to have 2.5 V be our no breathing voltage so that extreme inhalations or exhalations could be detected with our device.

2. Thermistor Amplification

The thermistor we choose for our project was the NTHS0402 from Vishay Dale. This thermistor has a thermal time constant of 5 seconds which makes it extremely sensitive. During experimentation we found that the change in voltage from a person breathing on the thermistor was on the order of 10 mV. Since this was too small of a change to work with we decided to amplify this change by using an Op Amp with a high pass filter. An Op Amp alone will not suffice because it will amplify the entire signal whereas we only want to amplify the change in voltage. Literature research shows that the average adult male breaths about 15-20 breaths/min and the average infant breaths about 30-60 breaths/min. Our slowest desired period is about 4 seconds. We choose the time constant for our high pass filter to be 22 seconds. This means that any signal with a period less than 22 seconds will be amplified by our op amp. We choose 22 seconds so that our device could detect hyperventilation as well as normal breathing. The time constant was set to 22 seconds by choosing R2 to by 10 kΩ and C1 to 2200 µF as seen in Figure 2. The gain was then set to 4 by choosing R3 to be 30 kΩ.

The output of this circuit goes to both PortA0 and PortB2. PortA0 is the input to the ADC while PortB2 is the + reference pin for the AC (see software design section).

3. Analog Comparator

The respiratory rate is measured by using an analog comparator (AC) to compare the amplified voltage across the thermistor to a reference voltage. Since the respiratory signal is approximately equivalent to a sine wave with a DC offset, we choose the reference voltage to be at the DC offset. However, patients of different ages will have different steady state breathing temperatures. For example older patients will breath out more hot air than younger patients. This means that the DC offset will be lower than those of younger patients. To automatically determine the reference voltage for a patient we used a low pass filter shown below in Figure 3. This low pass filter has a time constant of 22 seconds which means it rejects all of the signals we are interested in. Since it rejects the respiratory signal the output of this filter must be at the average value of the incoming signal. As the incoming signal is equivalent to a sine wave with a DC offset, the average value of the signal is the DC. The output of this filter than goes into the voltage reference pin of the AC as shown in Figure 3. The respiratory signal comes from PortB2 and goes into both the filter and positive voltage pin of the AC of the MCU. To achieve a time constant of 22 seconds R4 is 100 kΩ and C2 is 220 µF.

4. Capacitor Charger

The time constant for the thermistor amplification circuit described above is 22 seconds which means it takes several minutes for the capacitor to charge up. During this charging period the device does not work properly because the capacitor is not fully charged. To decrease this charging time another circuit was added with a smaller resistor so that the time constant for charging would be faster. The charging capacitor schematic is shown below in Figure 4. When PortB4 and PortB5 are set to 5 V and 0 V respectively (see software design for further details) the capacitor begins to charge through R6. Both R5 and R6 are 330 Ω so that they would provide as little resistance as possible. The time constant for charging then becomes 0.73 seconds and the total time for charging is about 6 seconds. R5 is necessary to provide protect for PortB4 so that it is not damaged.

5. LCD Display Button

In order to conserve power the user must hold down a button to turn the LCD on. This way the LCD is not on when it is not being used and it cannot be left on by mistake. This was accomplished by connecting the LCD Vcc pin to the MCU Vcc via a push button as shown in Figure 5. When the button is pushed the LCD Vcc pin receives 5 V. Resistor 10 and Rsesistor 7 are needed to ensure that the voltage at the pink node is below the threshold voltage of the MCU pins. This way PortB1 will read 0 V when the button isn�t pushed and 5 V when the button is pushed. Both R10 and R7 are 330 Ω.

The LCD we used the MDL(s)-16264 LCD from Vartronix along with a 10 kΩ trimpot to control the contrast.

6. Battery Monitor

To measure the voltage of the 9 V battery we used a voltage divider along with a low pass filter as shown in Figure 6 below. The voltage divider is used to convert the voltage range from 0-9 V to 0-5 V so that the MCU will not be damaged. The ADC is then used convert the analog voltage to a digital format so that the MCU and analyze it. The purpose of the low pass filter is to eliminate any high frequency signals that might occur. The time constant of the filter is 1 µs and is achieved by setting C2 to 1 nF and R8 to 1 kΩ. R9 is set to 3 kΩ so that the voltage divider outputs ¼ of the original voltage.

Figures

Main source code file

// Includes + Defines
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <avr/eeprom.h> 
#include <math.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <string.h>
//#define F_CPU 16000000 UL
#include <util/delay.h> // needed for lcd_lib
#include <avr/sleep.h>

#include "uart.h"

#define begin {
#define end }
#define t1 15 //every 0.25 seconds
#define t2 500 //every 8.2 seconds
#define bat_tol 101 //tolerance value of battery code
#define tol 8 //tolerance value of determine if patient is breathing code
FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW); //setup uart



//*************Macros************************************************
#define READ(U, N) ((U) >> (N) & 1u)
#define SET(U, N) ((void)((U) |= 1u << (N)))
#define CLR(U, N) ((void)((U) &= ~(1u << (N))))
#define FLIP(U, N) ((void)((U) ^= 1u << (N))) 


//*************Functions*********************************************
void thermistor(void);  //determine if patient is breathing
void battery(void);      //measure battery voltage
void display(void);      //display breathing rate (bpm) on LCD
void measure(void);      //measure breathing rate (bpm)
void initialize (void);    

//**************Variables***************************************
//LCD variables 
const int8_t LCD_initialize[] PROGMEM = "LCD Initialized\0";
const int8_t LCD_line[] PROGMEM = "line 1\0";
const int8_t LCD_number[] PROGMEM = "Number=\0";
int8_t lcd_buffer[20];	// LCD display buffer


volatile unsigned int time1, time2;  //time out variables
volatile int count;                  //keeps running count of clk cycles
float breathrate;                    //breathing rate bpm
char sample_old;                     //old time sample measured by ADC
char sample;                         //new time sample measured by ADC
volatile int tau1;                   //time 1 for respiration rate measurement
volatile int tau2;					 //time 2 for respiration rate measurement
int c;								 //counter for number of "no breaths"
volatile char measure_flag;   		 //set to one if AC ISR goes off
volatile int period;          		 //period of one breath in clk cycles
volatile char flag;          		 //set to one when AC ISR goes off
float avg_period;           		 //average period of one breath in clk cycles
char bat_samp;                		 //battery voltage sample

//************ISR************************************************

//***********Timeout Counter ISR********************************
// timer 0 compare ISR
ISR (TIMER0_COMPA_vect)
begin      
  //Decrement the three times if they are not already zero
  if (time1>0)	--time1; //Used to time the thermistor measurements
  if (time2>0) 	--time2; //Used to time the battery voltage measurements
  if (count == 20000) //reset count so it doesnt overflow
  begin
	  count = 0;
	  tau1 = 0;
  end
  count++;
end 


//**************AC ISR************************************
ISR (ANALOG_COMP_vect)
begin

	CLR(ACSR, ACIE);  		//turn off AC inturrupt
	flag = 1;  				//flag for turning on AC inturrupt

	tau2 = count;     		//store new count value
	period = tau2 - tau1;   //calculate period
	tau1 = tau2;    		//store old count value
	measure_flag = 1;  		//activate measure function
	
end 

//*************Main*********************************************
 //Main 
int main (void)
begin

//charge capacitors
	DDRB = 0b00110000; //set B5,B4 to output
	SET(PORTB,PORTB4); //set B4 to 5V

	_delay_ms(5000); //wait for 5 seconds while charging

	CLR(PORTB,PORTB4); //turn B4 off
	DDRB = 0b00000000; //turn DDRB to all inputs

  	initialize();

	//for uart
	stdout = stdin = stderr = &uart_str;
	fprintf(stdout,"Starting...\n\r"); 

 //main task scheduler loop 
  while(1)
  begin  
	//testing fprintf statements
	  	//fprintf(stdout,"while\n\r"); 
    	//fprintf(stdout,"second = %d\n\r ",second);
		//fprintf(stdout,"tau 1 = %d     tau2 = %d \n\r",tau1, tau2);
		//fprintf(stdout,"count = %d \n\r", count);
		//fprintf(stdout,"tau2 = %d \n\r",tau2);
		//fprintf(stdout,"period = %d\n\r ",period);
		//fprintf(stdout,"tau1 = %d \n\r",tau1);
	
	if (flag == 1) //for turning back on AC inturrupt
	begin
	 
		_delay_ms(10);
		SET(ACSR,ACI);
		SET(ACSR, ACIE); //turn on AC inturrupt

		flag = 0; //reset flag
	end
	
	if (time1==0){ time1=t1; thermistor();}  //determines if patient is 
											 //breathing or not

    if (time2==0){ time2=t2; battery();}    //measures battery life

	if (measure_flag == 1){measure_flag = 0; measure();} //measures breathing rate

	if (PINB & 0b00000010){display();}  //if display button is pushed
	                                    //activate the display function

  end
end //main


//**************Thermistor****************************
void thermistor(void)
begin

	ADMUX = (1<<REFS0) | (1<<ADLAR) ;  //turn on left adjust result, turn on external reference

	
	while(ADCSRA & (1<<ADSC)) ;  // wait for conversion

	    sample_old = sample;  
	    sample = ADCH;      	// take sample from ADC

		ADCSRA |= (1<<ADSC); 	// shift left

		if(abs(sample_old - sample) <= tol) 
		begin
	
			c++; 				// increment counter if "no breath" detected
		
			if(c >= 10) {

			 //turn on pwm 
 		 
			 SET(DDRD,DDD5); 
			 TCCR1B = (1<<WGM12) | (1<< CS11); 	

			 TCCR1A = (1<<COM1A0); 
	         OCR1A = 255;

	         breathrate = 0;	//since patient isn't breathing, breathrate is 0

		     } 

		end 

		else 
		begin
			c = 0;				// reset "no breath" count
			TCCR1A = 0;			// keep PWM off
		end 
end

//*************Battery*******************************
void battery(void)
begin


		ADMUX = (1<<REFS0) | (1<<ADLAR) + 1 ;  //turn on left adjust result, turn on second external reference

		ADCSRA |= (1<<ADSC);

		while(ADCSRA & (1<<ADSC)) ;			  //wait for conversion

		bat_samp = ADCH;					  //set variable to ADC sample

		//for testing
		fprintf(stdout, "bat samp = %d\n\r", bat_samp);

		if(bat_samp <= bat_tol) 
		begin
		 
		 //turn on pwm 
		 
		 SET(DDRD,DDD5); 
		 TCCR1B = (1<<WGM12) | (1<<CS11) | (1<<CS10); 	

		 TCCR1A = (1<<COM1A0); 
         OCR1A = 255; 
	 
		 _delay_ms(1000); 					//pwm on for 5 seconds

		 TCCR1A = 0;
		 
		end 

end

//*************Display*******************************
void display(void)
begin
	
    LCDinit();	      		//initialize the display
	LCDcursorOFF();
	LCDclr();				//clear the display 

    //sprintf(lcd_buffer, "win"); for testing

	sprintf(lcd_buffer, "%f Bpm", breathrate);           
	LCDGotoXY(0,0);
	LCDstring(lcd_buffer, strlen(lcd_buffer));
    //fprintf(stdout,"display \n\r"); for testing

end

//*************Measure*******************************
void measure(void)
begin

	avg_period = 0.75*avg_period + 0.25*period; //calculate avg period
	breathrate = 3/(avg_period*0.00164);        //convert to bpm
		
	//for testing
    //fprintf(stdout,"breathrate: %f B/min\n\r", breathrate);

end // measure task

//****************Initialize*****************************
void initialize(void)
begin

	DDRA = 0b00000000;                	 //Make PortA all inputs
	PORTA = 0b00000000;              	 //turn off pull up resistors 


 	DDRB = 0b01000000;   				 //set B6 to output
	SET(PORTB,PORTB6);  				 //set B6 to 5V output

	ADMUX = (1<<REFS0) | (1<<ADLAR) ;    //turn on left adjust result, turn on external reference
	ADCSRA = (1<<ADEN) | (1<<ADSC) + 7;  //turn on ADC, start conversion and set sample rate to 1Mhz

	//set up timer 0 for 1 mSec timebase 
	TIMSK0= (1<<OCIE0A);				 //turn on timer 0 cmp match ISR 
	OCR0A = 255;  						 //set the compare reg to 256 time ticks

	//turn on AC   
  	SET(ACSR, ACIE);   					 //turn analog input capture on
  	SET(ACSR, ACIS1);    				 //ACIS1 and ACIS0 make the comparater trigger on the rising edge

	//set prescalar to divide by 1024 
	TCCR0B= 5; 	

	// turn on clear-on-match
	TCCR0A= (1<<WGM01) ;

	//init variables
	flag = 0;
	avg_period = 0;

    time1=t1;
    time2=t2;

	uart_init();
	
	//crank up the ISRs
	sei();
end

LCD header file

//*****************************************************************************
//
// File Name	: 'lcd_lib.h'
// Title		: 8 and 4 bit LCd interface
// Author		: Scienceprog.com - Copyright (C) 2007
// Created		: 2007-03-29
// Revised		: 2007-08-08
// Version		: 1.0
// Target MCU	: Atmel AVR series
//
// This code is distributed under the GNU Public License
//		which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************
#ifndef LCD_LIB
#define LCD_LIB

#include <inttypes.h>


//Uncomment this if LCD 4 bit interface is used
//******************************************
#define LCD_4bit
//***********************************************

#define LCD_RS	0 	//define MCU pin connected to LCD RS
#define LCD_RW	1 	//define MCU pin connected to LCD R/W
#define LCD_E	2	//define MCU pin connected to LCD E
#define LCD_D0	0	//define MCU pin connected to LCD D0
#define LCD_D1	1	//define MCU pin connected to LCD D1
#define LCD_D2	2	//define MCU pin connected to LCD D1
#define LCD_D3	3	//define MCU pin connected to LCD D2
#define LCD_D4	4	//define MCU pin connected to LCD D3
#define LCD_D5	5	//define MCU pin connected to LCD D4
#define LCD_D6	6	//define MCU pin connected to LCD D5
#define LCD_D7	7	//define MCU pin connected to LCD D6
#define LDP PORTC	//define MCU port connected to LCD data pins
#define LCP PORTC	//define MCU port connected to LCD control pins
#define LDDR DDRC	//define MCU direction register for port connected to LCD data pins
#define LCDR DDRC	//define MCU direction register for port connected to LCD control pins

#define LCD_CLR             0	//DB0: clear display
#define LCD_HOME            1	//DB1: return to home position
#define LCD_ENTRY_MODE      2	//DB2: set entry mode
#define LCD_ENTRY_INC       1	//DB1: increment
#define LCD_ENTRY_SHIFT     0	//DB2: shift
#define LCD_ON_CTRL         3	//DB3: turn lcd/cursor on
#define LCD_ON_DISPLAY      2	//DB2: turn display on
#define LCD_ON_CURSOR       1	//DB1: turn cursor on
#define LCD_ON_BLINK        0	//DB0: blinking cursor
#define LCD_MOVE            4	//DB4: move cursor/display
#define LCD_MOVE_DISP       3	//DB3: move display (0-> move cursor)
#define LCD_MOVE_RIGHT      2	//DB2: move right (0-> left)
#define LCD_FUNCTION        5	//DB5: function set
#define LCD_FUNCTION_8BIT   4	//DB4: set 8BIT mode (0->4BIT mode)
#define LCD_FUNCTION_2LINES 3	//DB3: two lines (0->one line)
#define LCD_FUNCTION_10DOTS 2	//DB2: 5x10 font (0->5x7 font)
#define LCD_CGRAM           6	//DB6: set CG RAM address
#define LCD_DDRAM           7	//DB7: set DD RAM address
// reading:
#define LCD_BUSY            7	//DB7: LCD is busy
#define LCD_LINES			2	//visible lines
#define LCD_LINE_LENGTH		16	//line length (in characters)
// cursor position to DDRAM mapping
#define LCD_LINE0_DDRAMADDR		0x00
#define LCD_LINE1_DDRAMADDR		0x40
#define LCD_LINE2_DDRAMADDR		0x14
#define LCD_LINE3_DDRAMADDR		0x54
// progress bar defines
#define PROGRESSPIXELS_PER_CHAR	6


void LCDsendChar(uint8_t);		//forms data ready to send to 74HC164
void LCDsendCommand(uint8_t);	//forms data ready to send to 74HC164
void LCDinit(void);			//Initializes LCD
void LCDclr(void);				//Clears LCD
void LCDhome(void);			//LCD cursor home
void LCDstring(uint8_t*, uint8_t);	//Outputs string to LCD
void LCDGotoXY(uint8_t, uint8_t);	//Cursor to X Y position
void CopyStringtoLCD(const uint8_t*, uint8_t, uint8_t);//copies flash string to LCD at x,y
void LCDdefinechar(const uint8_t *,uint8_t);//write char to LCD CGRAM 
void LCDshiftRight(uint8_t);	//shift by n characters Right
void LCDshiftLeft(uint8_t);	//shift by n characters Left
void LCDcursorOn(void);		//Underline cursor ON
void LCDcursorOnBlink(void);	//Underline blinking cursor ON
void LCDcursorOFF(void);		//Cursor OFF
void LCDblank(void);			//LCD blank but not cleared
void LCDvisible(void);			//LCD visible
void LCDcursorLeft(uint8_t);	//Shift cursor left by n
void LCDcursorRight(uint8_t);	//shif cursor right by n
// displays a horizontal progress bar at the current cursor location
// <progress> is the value the bargraph should indicate
// <maxprogress> is the value at the end of the bargraph
// <length> is the number of LCD characters that the bargraph should cover
//adapted from AVRLIB - displays progress only for 8 bit variables
void LCDprogressBar(uint8_t progress, uint8_t maxprogress, uint8_t length);


#endif

LCD source code

//*****************************************************************************
//
// File Name	: 'lcd_lib.c'
// Title		: 8 and 4 bit LCd interface
// Author		: Scienceprog.com - Copyright (C) 2007
// Created		: 2007-03-29
// Revised		: 2007-08-08
// Version		: 1.0
// Target MCU	: Atmel AVR series
//
// This code is distributed under the GNU Public License
//		which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************
#include "lcd_lib.h"
#include <inttypes.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

const uint8_t LcdCustomChar[] PROGMEM=//define 8 custom LCD chars
{
	0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, // 0. 0/5 full progress block
	0x00, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, // 1. 1/5 full progress block
	0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, // 2. 2/5 full progress block
	0x00, 0x1F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1F, 0x00, // 3. 3/5 full progress block
	0x00, 0x1F, 0x1E, 0x1E, 0x1E, 0x1E, 0x1F, 0x00, // 4. 4/5 full progress block
	0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, // 5. 5/5 full progress block
	0x03, 0x07, 0x0F, 0x1F, 0x0F, 0x07, 0x03, 0x00, // 6. rewind arrow
	0x18, 0x1C, 0x1E, 0x1F, 0x1E, 0x1C, 0x18, 0x00  // 7. fast-forward arrow
};


void LCDsendChar(uint8_t ch)		//Sends Char to LCD
{

#ifdef LCD_4bit
	//4 bit part
	LDP=(ch&0b11110000);
	LCP|=1<<LCD_RS;
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);	
	LCP&=~(1<<LCD_RS);
	_delay_ms(1);
	LDP=((ch&0b00001111)<<4);
	LCP|=1<<LCD_RS;
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);	
	LCP&=~(1<<LCD_RS);
	_delay_ms(1);
#else
	//8 bit part
	LDP=ch;
	LCP|=1<<LCD_RS;
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);	
	LCP&=~(1<<LCD_RS);
	_delay_ms(1);
#endif
}
void LCDsendCommand(uint8_t cmd)	//Sends Command to LCD
{
#ifdef LCD_4bit	
	//4 bit part
	LDP=(cmd&0b11110000);
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	LDP=((cmd&0b00001111)<<4);	
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
#else
	//8 bit part
	LDP=cmd;
	LCP|=1<<LCD_E;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);	
#endif
}
void LCDinit(void)//Initializes LCD
{
#ifdef LCD_4bit	
	//4 bit part
	_delay_ms(15);
	LDP=0x00;
	LCP=0x00;
	LDDR|=1<<LCD_D7|1<<LCD_D6|1<<LCD_D5|1<<LCD_D4;
	LCDR|=1<<LCD_E|1<<LCD_RW|1<<LCD_RS;
   //---------one------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4; //4 bit mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//-----------two-----------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4; //4 bit mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//-------three-------------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|0<<LCD_D4; //4 bit mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//--------4 bit--dual line---------------
	LCDsendCommand(0b00101000);
   //-----increment address, invisible cursor shift------
	LCDsendCommand(0b00001100);
		//init 8 custom chars
	uint8_t ch=0, chn=0;
	while(ch<64)
	{
		LCDdefinechar((LcdCustomChar+ch),chn++);
		ch=ch+8;
	}


#else
	//8 bit part
	_delay_ms(15);
	LDP=0x00;
	LCP=0x00;
	LDDR|=1<<LCD_D7|1<<LCD_D6|1<<LCD_D5|1<<LCD_D4|1<<LCD_D3
			|1<<LCD_D2|1<<LCD_D1|1<<LCD_D0;
	LCDR|=1<<LCD_E|1<<LCD_RW|1<<LCD_RS;
   //---------one------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4|0<<LCD_D3
			|0<<LCD_D2|0<<LCD_D1|0<<LCD_D0; //8 it mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//-----------two-----------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4|0<<LCD_D3
			|0<<LCD_D2|0<<LCD_D1|0<<LCD_D0; //8 it mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//-------three-------------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4|0<<LCD_D3
			|0<<LCD_D2|0<<LCD_D1|0<<LCD_D0; //8 it mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
	//--------8 bit dual line----------
	LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4|1<<LCD_D3
			|0<<LCD_D2|0<<LCD_D1|0<<LCD_D0; //8 it mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(1);
   //-----increment address, invisible cursor shift------
	LDP=0<<LCD_D7|0<<LCD_D6|0<<LCD_D5|0<<LCD_D4|1<<LCD_D3
			|1<<LCD_D2|0<<LCD_D1|0<<LCD_D0; //8 it mode
	LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;		
	_delay_ms(1);
	LCP&=~(1<<LCD_E);
	_delay_ms(5);
		//init custom chars
	uint8_t ch=0, chn=0;
	while(ch<64)
	{
		LCDdefinechar((LcdCustomChar+ch),chn++);
		ch=ch+8;
	}

#endif
}			
void LCDclr(void)				//Clears LCD
{
	LCDsendCommand(1<<LCD_CLR);
}
void LCDhome(void)			//LCD cursor home
{
	LCDsendCommand(1<<LCD_HOME);
}
void LCDstring(uint8_t* data, uint8_t nBytes)	//Outputs string to LCD
{
register uint8_t i;

	// check to make sure we have a good pointer
	if (!data) return;

	// print data
	for(i=0; i<nBytes; i++)
	{
		LCDsendChar(data[i]);
	}
}
void LCDGotoXY(uint8_t x, uint8_t y)	//Cursor to X Y position
{
	register uint8_t DDRAMAddr;
	// remap lines into proper order
	switch(y)
	{
	case 0: DDRAMAddr = LCD_LINE0_DDRAMADDR+x; break;
	case 1: DDRAMAddr = LCD_LINE1_DDRAMADDR+x; break;
	case 2: DDRAMAddr = LCD_LINE2_DDRAMADDR+x; break;
	case 3: DDRAMAddr = LCD_LINE3_DDRAMADDR+x; break;
	default: DDRAMAddr = LCD_LINE0_DDRAMADDR+x;
	}
	// set data address
	LCDsendCommand(1<<LCD_DDRAM | DDRAMAddr);
	
}
//Copies string from flash memory to LCD at x y position
//const uint8_t welcomeln1[] PROGMEM="AVR LCD DEMO\0";
//CopyStringtoLCD(welcomeln1, 3, 1);	
void CopyStringtoLCD(const uint8_t *FlashLoc, uint8_t x, uint8_t y)
{
	uint8_t i;
	LCDGotoXY(x,y);
	for(i=0;(uint8_t)pgm_read_byte(&FlashLoc[i]);i++)
	{
		LCDsendChar((uint8_t)pgm_read_byte(&FlashLoc[i]));
	}
}
//defines char symbol in CGRAM
/*
const uint8_t backslash[] PROGMEM= 
{
0b00000000,//back slash
0b00010000,
0b00001000,
0b00000100,
0b00000010,
0b00000001,
0b00000000,
0b00000000
};
LCDdefinechar(backslash,0);
*/
void LCDdefinechar(const uint8_t *pc,uint8_t char_code){
	uint8_t a, pcc;
	uint16_t i;
	a=(char_code<<3)|0x40;
	for (i=0; i<8; i++){
		pcc=pgm_read_byte(&pc[i]);
		LCDsendCommand(a++);
		LCDsendChar(pcc);
		}
}

void LCDshiftLeft(uint8_t n)	//Scrol n of characters Right
{
	for (uint8_t i=0;i<n;i++)
	{
		LCDsendCommand(0x1E);
	}
}
void LCDshiftRight(uint8_t n)	//Scrol n of characters Left
{
	for (uint8_t i=0;i<n;i++)
	{
		LCDsendCommand(0x18);
	}
}
void LCDcursorOn(void) //displays LCD cursor
{
	LCDsendCommand(0x0E);
}
void LCDcursorOnBlink(void)	//displays LCD blinking cursor
{
	LCDsendCommand(0x0F);
}
void LCDcursorOFF(void)	//turns OFF cursor
{
	LCDsendCommand(0x0C);
}
void LCDblank(void)		//blanks LCD
{
	LCDsendCommand(0x08);
}
void LCDvisible(void)		//Shows LCD
{
	LCDsendCommand(0x0C);
}
void LCDcursorLeft(uint8_t n)	//Moves cursor by n poisitions left
{
	for (uint8_t i=0;i<n;i++)
	{
		LCDsendCommand(0x10);
	}
}
void LCDcursorRight(uint8_t n)	//Moves cursor by n poisitions left
{
	for (uint8_t i=0;i<n;i++)
	{
		LCDsendCommand(0x14);
	}
}
//adapted fro mAVRLIB
void LCDprogressBar(uint8_t progress, uint8_t maxprogress, uint8_t length)
{
	uint8_t i;
	uint16_t pixelprogress;
	uint8_t c;

	// draw a progress bar displaying (progress / maxprogress)
	// starting from the current cursor position
	// with a total length of "length" characters
	// ***note, LCD chars 0-5 must be programmed as the bar characters
	// char 0 = empty ... char 5 = full

	// total pixel length of bargraph equals length*PROGRESSPIXELS_PER_CHAR;
	// pixel length of bar itself is
	pixelprogress = ((progress*(length*PROGRESSPIXELS_PER_CHAR))/maxprogress);
	
	// print exactly "length" characters
	for(i=0; i<length; i++)
	{
		// check if this is a full block, or partial or empty
		// (u16) cast is needed to avoid sign comparison warning
		if( ((i*(uint16_t)PROGRESSPIXELS_PER_CHAR)+5) > pixelprogress )
		{
			// this is a partial or empty block
			if( ((i*(uint16_t)PROGRESSPIXELS_PER_CHAR)) > pixelprogress )
			{
				// this is an empty block
				// use space character?
				c = 0;
			}
			else
			{
				// this is a partial block
				c = pixelprogress % PROGRESSPIXELS_PER_CHAR;
			}
		}
		else
		{
			// this is a full block
			c = 5;
		}
		
		// write character to display
		LCDsendChar(c);
	}

}

Warning: embedding parts within the project story has been deprecated. To edit, remove or add more parts, go to the "Hardware" tab. To remove this list from the story, click on it to trigger the context menu, then click the trash can button (this won't delete it from the "Hardware" tab).
	9V battery (generic)
	Through Hole 1nF Capacitor
	Through Hole 2200µF Capacitor
	Through Hole 220µF Capacitor
	Through-Hole 100kΩ Resistor
	Through-Hole 30kΩ Resistor
	Through-Hole 10kΩ Resistor
	Through-Hole 3kΩ Resistor
	Through-Hole 1kΩ Resistor
	Through-Hole 330Ω Resistor
	Op Amp LF353N
	Button
	Piezo Electric Speaker
	10K Trimpot
	NTC Thermistor SMD 402
	Nebulizer Mask
	LCD
	AtMega1284p Target Board
	White Board

References

Datasheets

• Thermistor
• Operational Amplifier
• LCD Screen
• AtMega1284p

Vendors

• Nebulizer Mask

Background Info

• Analog Sampling
• Thermistors
• Respiratory Monitors

References

• Original project page on ECE 4670
• IEEE Code of Ethics
• Template Website
• Header for LCD library
• Source code for LCD library