Ontwerp van een ademhalingssensor op basis van een...

Ontwerp van een ademhalingssensor op basis van een

accelerometer

Pepijn Mistiaen

Promotoren: prof. dr. ir. Jan Vanfleteren, dr. ir. Jan Doutreloigne

Begeleider: Benôıt Huyghe

Masterproef ingediend tot het behalen van de academische graad van Master in de ingeni-

eurswetenschappen: elektrotechniek

Vakgroep Elektronica en informatiesystemen

Voorzitter: prof. dr. ir. Jan Vancampenhout

Faculteit Ingenieurswetenschappen

Academiejaar 2008-2009

VOORWOORD

Voorwoord

Hierbij wil ik in de eerste plaats mijn begeleider Benôıt bedanken, voor zijn steun en goede

raad als er problemen opdoken. Zijn ervaring bij bepaalde aspecten van deze scriptie

hebben mij veel bijgebracht. Ook mijn promotoren wil ik bedanken voor het vertrouwen

en de kans om mij te verdiepen in dit onderwerp.

Het mag hier niet ontbreken mijn ouders te vermelden. Zij hebben mij door de jaren heen

gesteund en mij de kansen geboden deze studie te verwezenlijken.

Mijn vriendin, Lorena, en al de andere mensen die me hebben gemotiveerd en gesteund,

mij hebben bijgestaan, mij raad hebben gegeven, enz. Hartelijk bedankt.

Pepijn Mistiaen, augustus 2009

TOELATING TOT BRUIKLEEN

Toelating tot bruikleen

“De auteur geeft de toelating deze scriptie voor consultatie beschikbaar te stellen en delen

van de scriptie te kopiëren voor persoonlijk gebruik.

Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met

betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van

resultaten uit deze scriptie.”

Pepijn Mistiaen, augustus 2009

Ontwerp van een ademhalingssensor

op basis van een accelerometerdoor

Pepijn Mistiaen

Promotoren: prof. dr. ir. Jan Vanfleteren, dr. ir. Jan Doutreloigne

Begeleider: Benôıt Huyghe

Masterproef ingediend tot het behalen van de academische graad van Master in de

ingenieurswetenschappen: elektrotechniek

Academiejaar 2008-2009

Vakgroep Elektronica en informatiesystemen

Voorzitter: prof. dr. ir. Jan Vancampenhout

Faculteit Ingenieurswetenschappen

Samenvatting

In dit werk wordt de ontwikkeling van een ademhalingssensor op basis van acelerometersbeschreven. Er werd een hardwareplatform ontworpen, die toelaat om zich te concentrerenop de verdere ontwikkeling van de ademhalingsdetectie algoritmes. Tevens werd een eerstestap gezet in de richting van microcontroller vriendelijke implementatie van deze detectiealgoritmes.

Trefwoorden

ademhalingssensor, SIDS, accelerometer, radix-2/4/8

Design of a breathing sensor based onaccelerometers

Pepijn Mistiaen

Supervisor(s): prof. dr. ir. Jan Vanfleteren, dr. ir. Jan Doutreloigne and Benot Huyghe

Abstract— This article covers the steps taken in designing a breathingsensor based on accelerometers. This is meant to be an independant sensorproviding a means to prevent the Sudden Infant Death Syndrome (SIDS).The hardware design is covered, as well as an first step in to the embeddedalgoritms to detect breathing.

Keywords—breathing sensor, SIDS, accelerometer, radix-2/4/8

I. INTRODUCTION

THE Sudden Infant Death Syndrome stands for the suddendeath of an infant of two weeks to one year old with noapparent reason. The breathing sensor is designed to detect thebreathing of the infant and in case breathing stops the parents orcaretaking personnel can be warned about the danger the infantis in.

The breathing sensor has to fulfill a number of demands. Ithas to detect the breathing in a reliable manner. A means towarn somebody if no breathing was detected and the wearingcomfort should be as high as possible. These demands can betranslated into hardware requirements.

With the selected hardware one still needs signal processingalgorithms to detect the breathing. MATLAB was used to anal-yse, develop and evaluate the algoritms.

II. HARDWARE

With the accelerometer the movements of the chest are mea-sured, caused by breathing. These movements are small so asensitive sensor with low noise levels is needed. In general ana-log accelerometers have better characteristics concerning sensi-tivity and noise levels. Although their slightly inferior perfor-mance a digital accelerometer was chosen, bypassing the needof an ADC. They are easy to interface and can be easily linked inan bus configuration, an advantage if using multiple accelerom-eters. They also draw less current than their analog counterparts,an advantage in independant battery powered applications. TheLIS302DL of ST Microelectronics was used in the breathingsensor.

Fig. 1. System architecture final design

The system architecture of the final design is shown infigure 1. Two sensors are connected to the microcontroller(MSP430F149). There is a PC interface, for programming anddebugging purposes. A wireless interface is also present. Abuzzer serves as an audible alarm and the circuit is powered bya coin cell battery.

A photo of the breathing sensor is given in figure 2, it is a one-layered design realised on a flexible substrate using only SMDs.The flexible substrate is to ensure the comfortable wearing. Onecan see three sensor nodes, with two of them connected to thealarm node.

Fig. 2. Photo of the alarm node together with sensor nodes

III. ANALYSIS

Out of the data provided by the accelerometers, the breath-ing has to be detected. For infants until a year old the averagebreathing rate is abount 30 to 40 breaths per minute, which is afrequency ranging from 0.5 Hz to 0.67 Hz. A commercial sys-tem, Nanny Care[1], goes into alarm if the breathing rate dropsbelow 8 breaths per minute or when no breath was detected for20 s. If the same extremes are used, this means a breathing fre-quency of 0.13 Hz still has to be detected. These frequenciesare all close to the DC level so if a peak has to be detected at thebreathing rate a filter to remove the DC level will be necessary.

Figure 3 shows the spectrum of a test measurement on anadult person taking around 16 breaths per minute (0.26 Hz). Therange of the spectrum is limited to 2 Hz and the DC level wasremoved before calculating the spectrum. One can clearly seea peak just above 0.2 Hz, so breathing can be detected with ac-celerometers.

A. Radix-2/4/8 algorithm

To calculate a frequency spectrum with a microcontroller oneneeds an efficient algorithm, minimizing the number of mul-tiplications and memory requirements for storing intermediate

Fig. 3. Frequency spectrum of measurement

results. The sample rate of the accelerometer was reduced to25 Hz so a 256 points FFT is sufficient to have an accuracy of0.1 Hz.

The radix-2/4/8 algorithm[3] is derived from the radix-2 algo-rithm[2], which comes down to splitting the basic DFT formula(1) into different parts.

Xk =N−1∑n=0

xne− 2πjN nk with k = 0 . . . N − 1 (1)

The used radix-2/4/8 algorithm combines the split radix-2/4with the split radix-2/8 and the basic radix-2 algorithm. Thebasic butterfly of this algorithm is shown in figure 4. How thesedifferent algorithms are combined into one butterfly is shown infigure 5.

Fig. 4. Radix-2/4/8 butterfly

Fig. 5. Radix-2/4/8 block

To calculate an 256 points FFT, a radix-4 butterfly is neededto divide the FFT in four smaller 64 points FFTs, these are thencalculated with two succesive radix-2/4/8 butterflies.

Calculating the frequency spectrum with this algorithm stillshows a peak around 0.2 Hz, as can be seen in figure 6.

Fig. 6. 256 points FFT calculated with the radix-2/4/8 algorithm

B. Results

With the algoritms in MATLAB some measurements wereperformed. Out of these measurements it was seen it is pos-sible to detect breathing while laying down on the back with asensor on the chest. It could also be detected laying down onthe chest with a sensor on the back. Both positions are posible.This is also why there were two sensor nodes incorporated in thebreathing sensor.

IV. FIRMWARE

The firmware is very basic because none of the breathing de-tection algorithms were ready for implementation. It only com-municates with the sensors and transmits this information withthe PC interface to MATLAB. The SPI protocol is used to com-municate with the sensors. The PC interface is the classic asyn-chronous serial interface.

V. CONCLUSION

A proof of concept was delivered with this work, it was shownthat breathing can be detected with accelerometers. There wasa hardware platform developed to facilate furhter developmentof breathing detection algorithms. A first step towards micro-controller implementation of the algorithms was taken, by theimplementation of the radix-2/4/8 algorithm in MATLAB.

There is still a long way to go to ensure reliable breathingdetection and the detection algorithms still need a lot of devel-opment before implementation in a microcontroller will be evenpossible.

REFERENCES[1] Nanny Care http://www.nannycare.nl[2] James W. Cooley and John W. Tuckey, An algorithm for the machine cal-

culation of complex Fourier series, Mathematics of Computation, pages297-301, April 1965.

[3] Lihong Jia, Yonghong Gao, Jouni Isoaho and Hannu Tenhunen, A newVLSI-oriented FFT algorithm and implementation, ASIC Conference 1998,Proceedings, Eleventh Annual IEEE International, pages 337-341, Septem-ber 1998.

INHOUDSOPGAVE INHOUDSOPGAVE

Inhoudsopgave

Voorwoord i

Toelating tot bruikleen ii

Overzicht iii

Extended abstract iv

Inhoudsopgave vi

Gebruikte afkortingen viii

1 Inleiding 1

1.1 Situatieschets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Aanpak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.3 Overzicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Hardware 3

2.1 Systeemarchitectuur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.1.1 Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.2 Controle-eenheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.3 Alarm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.4 PC interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Keuze componenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2.1 Accelerometer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2.2 Microcontroller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.3 Hulprealisaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3.1 Sensor breakout-board . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3.2 USB naar serieel interface . . . . . . . . . . . . . . . . . . . . . . . 8

2.4 Finale schakeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.4.1 Ontwerp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.4.2 Sensornode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

INHOUDSOPGAVE INHOUDSOPGAVE

2.4.3 Alarmnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Analyse 17

3.1 Analyse met MATLAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.2 Seriële interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.3 Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.3.1 Specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.3.2 Wave Digital Filters (WDF) . . . . . . . . . . . . . . . . . . . . . . 19

3.4 FFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4.1 Vlinder algoritmes . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.4.2 Gesplitste vlinder algoritmes . . . . . . . . . . . . . . . . . . . . . . 27

3.4.3 256 punts FFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.5 Uiteindelijke analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.5.1 Liggend op de rug met sensor op de borst . . . . . . . . . . . . . . 37

3.5.2 Liggend op de borst met de sensor op de rug . . . . . . . . . . . . . 38

3.5.3 Liggend op de rug met sensor op de borst zonder te ademen . . . . 42

4 Firmware 44

4.1 Ontwikkelomgeving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

4.2 Interface met de sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

4.3 Interface met de computer . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4.4 Hoofd programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5 Besluit 49

A Source code 50

A.1 MATLAB source code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

A.1.1 Seriële interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

A.1.2 256 punts FFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

A.2 C code voor de microcontroller . . . . . . . . . . . . . . . . . . . . . . . . 56

GEBRUIKTE AFKORTINGEN INHOUDSOPGAVE

Gebruikte afkortingen

SIDS Sudden Infant Death Syndrome

ADC Analog to Digital Converter

DMA Direct Memory Access

DIL Dual In Line

EEPROM Electrically Erasable Programmable Read-Only Memory

LED Light Emitting Diode

BOM Bill Of Materials

SMD Surface Mount Device

WDF Wave Digital Filters

FIR Finite Impulse Response

IIR Infinite Impulse Response

GUI Graphical User Interface

DFT Discrete Fourier Transformatie

SPI Serial Peripheral Interface

INLEIDING INHOUDSOPGAVE

Hoofdstuk 1

Inleiding

1.1 Situatieschets

Wiegendood, of beter ’Sudden Infant Death Syndrome’ (SIDS) letterlijk vertaald ’syn-

droom van het plots overlijden van een baby’. Het is een syndroom omdat het niet over

de oorzaak gaat maar wel over een duidelijk kenmerk. Het kenmerk is het plots overlijden

van een gezonde baby tussen de drie weken en een jaar. De term wiegendood komt vooral

door het feit dat de baby’s overlijden tijden hun slaap en bijgevolg in hun wieg[1]. De on-

derliggende oorzaak is per definitie niet bekend maar wetenschappers vermoeden dat het

te maken heeft met een onderontwikkeld ademhalingscentrum in de hersenen, waardoor er

geen prikkels worden gegeven als de baby een tekort aan zuurstof heeft. De hier voorge-

stelde ademhalingssensor wil dit syndroom tegen gaan, door de ademhaling te detecteren

en een alarm te geven, kunnen de ouders of verzorgend personeel op de hoogte worden

gebracht van het gevaar waarin de baby verkeerd. Ook stelt het wetenschappers in staat

de ademhaling te bestuderen tijdens de slaap van een baby.

1.2 Aanpak

In eerste instante werden er eisen vooropgesteld waaraan de ademhalingssensor moest

voldoen. Het moet in staat zijn om op een betrouwbare manier de ademhaling te detecteren,

in geval de ademhaling stopt moet het op een bepaalde manier alarm kunnen slaan en er

moet gezorgd worden dat het draagcomfort van de ademhalingssensor zo groot mogelijk is.

Vervolgens werd een rudimentair hardware blokschema opgesteld, waaruit de verschil-

lende hardware componenten gëıdentificeerd konden worden. Denkend aan de functionali-

teit, werden ruwe schattingen gemaakt over de nodige karakteristieken van de verschillende

1.3 Overzicht INHOUDSOPGAVE

componenten. In eerste tests moest blijken of deze ruwe schattingen voldoende waren of

moesten worden bijgesteld.

MATLAB werd gebruikt om verschillende algoritmes te testen en vervolgens verschil-

lende implementatiepistes te onderzoeken voor de ademhalingssensor.

Al de opgedane kennis wordt dan gebundeld in het finaal ontwerp van de ademhalings-

sensor.

1.3 Overzicht

In de volgende hoofdstukken vindt de lezer wat de verschillende evoluties waren zowel op

vlak van hardware, analyse en ook op vlak van firmware.

In het hoofdstuk 2 vindt men hoe het hardware gedeelte van deze ademhalingssensor

werd aangepakt, dit omvat een overzicht van de testschakelingen tot een gedetailleerde

beschrijving van het uiteindelijke ontwerp.

Het hoofdstuk 3 toont de lezer hoe de verschillende algoritmes tot stand gekomen zijn.

Ook de verschillende evoluties van die algoritmes om tot een implementatievriendelijk

algoritme te komen.

De firmware wordt beschreven in hoofdstuk 4, er wordt getoond hoe de verschillende

componenten werden geconfigureerd en geprogrammeerd om de beoogde functionaliteit te

behalen.

Er wordt in hoofdstuk 5 een algemeen besluit gevormd en er worden ook pistes meege-

deeld om deze applicatie verder uit te werken en te verbeteren.

HARDWARE INHOUDSOPGAVE

Hoofdstuk 2

Hardware

2.1 Systeemarchitectuur

Er moet een bepaalde systeemarchitectuur worden ontworpen waarmee de beoogde functi-

onaliteit wordt gehaald. Het is evident dat om de ademhaling te detecteren er een sensor

zal nodig zijn. Alarm slaan kan op verschillende manieren gebeuren. De omstandigheden

waarin de ademhalingssensor gebruikt wordt verduidelijken welke pistes mogelijk zijn. Het

zal worden gebruikt in de kinderkamer waar praktisch altijd een babyfoon aanwezig is, dus

een auditief alarm is voldoende om de ouders te verwittigen, ook al bevinden deze zich in

een andere kamer. Er is dan natuurlijk nog een component nodig die dit alles regelt en de

verschillende algoritmes herbergt om de ademhaling te detecteren uit de sensorgegevens.

De systeemarchitectuur kan dus worden samengevat in een blokschema zoals in figuur

2.1. Er werd hier ook nog een blok PC interface toegevoegd. Deze blok is nodig als we de

firmware willen debuggen en de algoritmes willen ontwikkelen met MATLAB.

Figuur 2.1: Blokschema van de systeemarchitectuur

2.1 Systeemarchitectuur INHOUDSOPGAVE

2.1.1 Sensor

Er is een sensor nodig om de ademhaling te detecteren. Om te weten welke sensoren in

aanmerking komen, is het nodig te begrijpen wat er gebeurt bij het ademhalen.

Bij het ademhalen worden de longen gevuld met lucht, dit heeft als gevolg dat de borst

ook mee uitzet op het ritme van de ademhaling. Er kan bijvoorbeeld een rekstrookje worden

gebruikt om de uitzetting van de borst te meten en zodoende de ademhaling te detecteren.

Daar de uitzetting van de borst ook een beweging is, kan het ook worden geregistreerd met

een accelerometer. Omdat de gemeten verandering in versnelling miniem zal zijn is een

gevoelig exemplaar nodig.

De keuze is uiteindelijk een accelerometer geworden, dit vooral wegens het grote aan-

bod op de markt en er werd al heel wat ervaring opgedaan met deze sensoren binnen de

vakgroep.

2.1.2 Controle-eenheid

Om alles te configureren en de algoritmes voor detectie van de ademhaling uit te voeren is

de voor de hand liggende keuze een microcontroller.

2.1.3 Alarm

Er zijn verschillende componenten in staat om geluid te produceren, in deze toepassing

is het van minder belang welk geluid het precies produceert zolang het maar voldoende

hoorbaar is. Een luidspreker zou het ontwerp te ver drijven en is ook totaal overbodig, een

piezo-elektrische buzzer daarentegen is er prima voor geschikt.

2.1.4 PC interface

Op een microcontroller van tegenwoordig is over het algemeen een seriële poort te vinden, de

huidige computers hebben deze interface echter niet meer (dit geldt zeker voor de laptops).

Deze is door de jaren heen langzaam verdrongen door de USB interface. Ook hier werd

een oplossing gezocht in de vorm van een USB naar seriëel interface.

2.2 Keuze componenten INHOUDSOPGAVE

2.2 Keuze componenten

2.2.1 Accelerometer

Een cruciale component in deze toepassing is de accelerometer. Deze moet namelijk de

ademhaling kunnen registreren. Omdat bij de ademhaling de versnellingen klein zijn, is

het belangrijk een sensor te hebben die gevoelig genoeg is en waarbij het ruisniveau zo

laag mogelijk is. Omdat het om een batterij gevoede schakeling gaat werd ook rekening

gehouden met het vermogen die de sensor nodig heeft. Aan de hand van al deze parameters

werden verschillende sensoren vergeleken en uiteindelijk een keuze gemaakt. In tabellen

2.1 tot 2.3 vindt men een overzicht van verschillende accelerometers terug.

Hoewel de analoge sensoren gevoelig beter zijn qua ruis werd toch een digitale sensor ge-

kozen, dit wegens de gemakkelijke interface met de microcontroller. Bovendien verbruiken

deze sensoren over het algemeen minder energie. Bij analoge sensoren zal de analoog naar

digitaal conversie gebeuren door de ADC van de microcontroller, deze conversie maakt dat

de microcontroller nog wat extra energie zal gebruiken. Een voordeel van analoge senso-

ren is dat een eventueel nodige filtering nog voor de ADC kan gebeuren, wat afhankelijk

van de nodige filter heel wat rekenkracht vereist van de microcontroller. Daarbij gaat de

voorkeur uit naar de KXSD9-2050 van Kionix, echter door moeilijke verkrijgbaarheid werd

uiteindelijk de LIS302DL van ST Microelectronics gebruikt als sensor.

2.2.2 Microcontroller

Nog een belangrijke component is de microcontroller, dit is het hart van de schakeling.

Hiermee worden de sensoren geconfigureerd en uitgelezen, waarna met algoritmes de adem-

haling wordt gedetecteerd. De algoritmes kunnen, afhankelijk van de complexiteit heel

rekenintensief zijn. Daarom moet het een performante microcontroller zijn. Gelet op het

feit dat de schakeling gevoed wordt door een batterij, speelt ook het vermogen een rol

en een low power microcontroller is zeker aangewezen. Binnen de vakgroep werd al reeds

meerdere malen gewerkt met de MSP430 familie van Texas Instruments, de MSP430F149

werd gekozen wegens beschikbare headerboards en de aanwezige hardware multiplier blok

en de Direct Memory Access (DMA) blok.

Verder zijn er voor deze toepassing geen speciale componenten gebruikt.

2.2 Keuze componenten INHOUDSOPGAVE

Analog Devices

ADXL203 ADXL204 ADXL213

Interface analoog digitaal (PWM)

Assen X,Y

Package 5x5x2mm LCC

Voeding 3 tot 6 V (typ. 5 V) 3 tot 6 V (typ. 3, 3 V) 3 tot 6 V (typ. 5 V)

Vermogen 0, 7 mA @ 5 V 0, 5 mA @ 3, 3 V 0, 7 mA @ 5 V

Bereik ±1, 7 g ±1, 2 gGevoeligheid 1000 mV/g 620 mV/g 30 /g

Ruis

max. 3 mV rms -

typ. 1 mV rms -

110 µg/√

Hz 170 µg/√

Hz 160 µg/√

Hz

Tabel 2.1: Accellerometers van Analog Devices

ST Microelectronics

LIS302SG LIS302DL

Interface analoog digitaal (I2C/SPI)

Assen X,Y,Z

Package 3x5x0,9 LGA-14

Voeding 3 tot 3, 6 V (typ. 3, 3 V)

Vermogen 0, 65 mA @ 3, 3 V 0, 3 mA @ 2, 5 V

Bereik ±2 g ±2 g - ±8 gGevoeligheid 479 mV/g 18 mg/digit - 72 mg/digit

Ruis 200 µg/√

Hz -

LIS331AL LIS331DL

Interface analoog digitaal (I2C/SPI)

Assen X,Y,Z

Package 3x3x1 LGA-16

Voeding 3 tot 3, 6 V (typ. 3, 3 V) 2,16 tot 3, 6 V (typ. 2, 5 V)

Vermogen 0, 65 mA @ 3, 3 V 0, 3 mA @ 2, 5 V

Bereik ±2 g ±2 g - ±8 gGevoeligheid 479 mV/g 18 mg/digit - 72 mg/digit

Ruis 300 µg/√

Hz -

Tabel 2.2: Accelerometers van ST Microelectronics

2.3 Hulprealisaties INHOUDSOPGAVE

Kionix

KXPB5-2050 KXRB5-2050 KXSD9-2050

Interface analoog (MUX) digitaal (I2C/SPI)

Assen X,Y,Z

Package 3x5x0,9 LGA

Voeding 2,5 tot 5, 25 V (typ. 3, 3 V)

Vermogen 0, 5 mA @ 3, 3 V 0, 22 mA @ 3, 3 V

Bereik ±2 g ±2 g (±1, 5 g tot ±6 g) ±2 g, 4 g, 6 g, 8 gGevoeligheid 660 mV/g 819, 410, 273 en 205 /g

Ruis 175 µg/√

Hz 75 µg/√

Hz 750 µg/√

Hz

Tabel 2.3: Accelerometers van Kionix

2.3 Hulprealisaties

2.3.1 Sensor breakout-board

Om gemakkelijk aan prototyping te doen werd een adapterprint gemaakt naar de stan-

daard DIL afmetingen, zodat de sensor gemakkelijk te gebruiken is op een breadboard.

Het schema wordt gegeven in figuur 2.2 en de layout in figuur 2.3. Hierbij werden de

ontkoppelcondensatoren en een pull-down weerstand al bij de sensor geplaatst. Een foto

van het sensor breakout-board kan worden bekeken in figuur 2.4.

Figuur 2.2: Schema van het breakout-board voor de sensor


Figuur 2.3: Layout van het breakout-board voor de sensor

Figuur 2.4: Foto van het breakout-board voor de sensor

2.3.2 USB naar serieel interface

Om het debuggen van de firmware te vergemakkelijken werd ook een USB naar seriëel

interface gemaakt. Deze is gebaseerd op de FT232BM chip van FTDI. Het reference

design van de datasheet werd gevolgd waarbij een aparte spanningsregelaar van 3, 3 V

werd bijgezet samen met een jumper om de I/O niveau’s te kunnen kiezen tussen 3, 3 V en

5 V. Verder zijn ook alle RS232 signalen naar buiten gebracht via headers alsook de twee

verschillende voedingsspanningen. Het schema wordt gegeven in figuur 2.5.

Aan de hand van het schema werd ook een layout ontworpen voor deze USB naar

serieel interface. Het ontwerp werd zo compact mogelijk gehouden en heeft de uiteindelijke

afmetingen van 29 mm op 65 mm. Figuur 2.6 toont de layout en figuur 2.7 toont een foto

van de USB naar serieel interface.

Tabel 2.4 geeft een overzicht van alle componenten die nodig zijn om de USB naar

serieel interface te maken.


Figuur 2.5: Schema van de USB naar serieel interface

Figuur 2.6: Layout van de USB naar serieel interface


Naam Code Omschrijving Farnell nr.

IC1 FT232BL USB chip 9519769

IC2 LP5951MF-3.3 spanningsregelaar 1312657

IC3 93C46B-I/SN EEPROM 9758186

L1 BK1608HM102-T ferriet ring 1611990

X1 1734346-1 USB connector 1321918

Y1 PBRC6.00HR50X000 6 MHz kristal 1209939

LED1 5988210107F rode LED 1465997

SV1 2213S-20G header 20 pins 2 rijen 1593446

JP1 2211S-03G header 3 pins 1 rij 1593412

- 0-0142270-3 jumper 4218152

R1,R2 - 27 Ω 0603 9233180

R3 - 1, 5 kΩ 0603 9233407

R4 - 1 MΩ 0603 9233741

R5 - 2, 2 kΩ 0603 9233423

R6 - 10 kΩ 0603 9233504

R7 - 470 Ω 0603 9233334

R8 - 150 Ω 0603 9233270

C1 - 10 nF 0603 431590

C2,C6 - 100 nF 0603 317287

C3,C4 - 1 µF 0603 9402080

C5 - 10 µF 0805 9402136

C7 - 33 nF 0603 431953

Tabel 2.4: BOM USB naar serieel interface

2.4 Finale schakeling INHOUDSOPGAVE

Figuur 2.7: Foto van de USB naar serieel interface

2.4 Finale schakeling

2.4.1 Ontwerp

Het uiteindelijk ontwerp van de ademhalingssensor wijkt niet erg af van wat initieel werd

voorgesteld in het blokschema van figuur 2.1. Figuur 2.8 toont dit uiteindelijk ontwerp in

de vorm van een blokschema. Het is ook snel te zien wat nu juist in de sensor en in de

alarmnode zit.

Figuur 2.8: Blokschema van het finaal ontwerp

Er zijn twee sensornodes die verbonden zijn met de alarmnode. Dit komt omdat men


in staat moet zijn om de ademhaling te detecteren als de baby zowel op de buik als op de

rug ligt. Daarom plaatsen we een sensornode op de rug en borst.

Er is ook een draadloze verbinding. Via deze weg kunnen de sensorgegevens zonder een

fysieke verbinding door een computer worden uitgelezen en geanalyseerd. Doordat er geen

fysieke verbinding nodig is verhoogt dit het comfort voor de baby. Toch is het noodzakelijk

om de mogelijkheid te hebben een fysieke verbinding met de alarmnode te maken, hoewel

deze bij normaal gebruik niet hoeft te worden gebruikt.

2.4.2 Sensornode

Het wordt als een apart onderdeel behandelt omdat zo de mogelijkheid behouden wordt de

sensor op een ideale plaats te positioneren onafhankelijk van de rest van de schakeling. Het

schema omvat enkel de ontkoppelde condensatoren voor de sensor en is bijgevolg eenvoudig

(figuur 2.9).

Figuur 2.9: Schema van de sensor node

De layout is enkelzijdig, op een flexibel substraat uitgevoerd en is zeer compact ge-

houden (13 mm x 15 mm). Figuur 2.10 toont de layout van de sensornode, hierbij zijn de

contacten voor de verbinding met de alarmnode goed te zien.

De lijst met de gebruikte componenten voor de sensornode is terug te vinden in tabel

2.5.


IC1 LIS302DL acellerometer 1435588

C1 - 100 nF 0603 1414610

C2 - 10 µF 0603 1463375

Tabel 2.5: BOM sensornode


Figuur 2.10: Layout van de sensor node

2.4.3 Alarmnode

De alarmnode is het kloppend hart van de ademhalingssensor. Hierop worden twee sen-

sornodes aangesloten. De microcontroller verwerkt de data van de sensoren en kan alarm

slaan via de buzzer. De gegevens kunnen ook draadloos worden doorgestuurd via de µMiRF

module van Sparkfun.

Het schema voor de alarmnode is gegeven in figuur 2.11. Via een connector kan de

microcontroller worden geprogrammeerd en wordt er ook een seriële verbinding naar buiten

gebracht om het debuggen van de firmware te vergemakkelijken.

Ook de layout van de alarmnode is op een enkelzijdig flexibel substraat uitgevoerd

(figuur 2.12). Het vergde wat creativiteit maar het uiteindelijke resultaat is een layout

zonder draadbruggen. Er werd ook plaats voorzien voor kristallen wanneer een nauwkeu-

rigere tijdsbasis nodig is of om de performantie van de microcontroller op te krikken door

hem wat hoger te klokken. In de layout is plaats voozien om de schakeling van stroom te

voorzien door een knoopcel zodat het geheel kan functioneren zonder dat er een verbinding

van buitenaf nodig is. De uiteindelijke afmetingen van de alarmnode zijn 95 mm x 43 mm.

De componenten nodig om deze alarmnode te maken worden weergegeven in tabel 2.6.

Figuur 2.13 toont een foto van realisatie van de alarmnode en de sensornode. Boven

de alarmnode zijn er drie sensornodes geplaatst, waarvan er twee verbonden zijn met de

alarmnode. In de alarmnode is het makkelijk de verschillende delen te identificeren. Van

links naar rechts staat eerst de houder voor de knoopcel, vervolgens de buzzer waarna de

microcontroller volgt en uiteindelijk de µMiRF module.


Figuur 2.11: Schema van de alarmnode


Figuur 2.12: Layout van de alarmnode


IC1 MSP430F149 microcontroller 1103048

B1 SMTU 2430-1-LF CR2430 houder 1216355

A1 KMTG1603 buzzer 1502709

- - Sparkfun uMiRF -

X3 53261-1271 SMD connector 1125363

R1-3 - 47 kΩ 0603 9238689

C3 - 100 nF 0603 1414610

C4 - 10 µF 0603 1463375

C7 - 10 nF 0603 1414609

Optioneel met externe kristallen

C1-2,C5-6 - 12 pF 0603 721979

Q1 - 32, 768 kHz kristal 1448101

X2 - 8 MHz 1611803

Tabel 2.6: BOM alarmnode


Figuur 2.13: Foto van de alarmnode samen met sensornodes

ANALYSE INHOUDSOPGAVE

Hoofdstuk 3

Analyse

3.1 Analyse met MATLAB

Eenmaal de testschakeling op het breadboard functioneerde kon van start gegaan worden

met het analyseren van de ruwe sensorgegevens met MATLAB. De microcontroller leest

de waarden van de accellerometer uit en verstuurt die vervolgens via de USB naar serieel

interface naar de computer waar met MATLAB de gegevens geanalyseerd kunnen worden.

De gegevens stromen binnen via een USB verbinding, waarbij een normale RS232 seriële

verbinding wordt geëmuleerd via de drivers van de FTDI chip. Om deze gegevens te kunnen

uitlezen met MATLAB moet deze dus toegang kunnen krijgen tot deze seriële poort.

Als de gegevens kunnen worden binnengenomen met MATLAB kan er naar relevante

informatie worden gezocht omtrent de ademhaling. Daar dit een repetitief fenomeen is zal

deze informatie opduiken wanneer we het spectrum van deze gegevens berekenen. Omdat

de frequentie van de ademhaling over het algemeen laag is (< 1 Hz) is het nodig om het

DC niveau van de gegevens te verwijderen d.m.v. een filter.

In de delen die volgen wordt dieper ingegaan op de verschillende onderdelen van de

MATLAB code en de evoluties om tot code te komen die gemakkelijk kan worden gëımplementeerd

in de microcontroller.

3.2 Seriële interface

Om de gegevens van de sensor te kunnen verwerken met MATLAB, werd de microcontroller

geprogrammeerd zodat deze gegevens via de USB naar serieel interface naar de computer

werden gezonden. Deze gegevensstroom moet dan echter nog met MATLAB uitgelezen

worden. De code die hiervoor zorgt is gegeven in het codefragment 3.1.

3.3 Filter INHOUDSOPGAVE

Codefragment 3.1: MATLAB code om de seriële poort uit te lezen

function s e r i a l i n t e r f a c e ( )% Opens a s e r i a l communication o b j e c ts1=s e r i a l ( ’ /dev/ttyUSB0 ’ , ’BaudRate ’ , 9600 , ’ Par i ty ’ , ’ none ’ , ’ DataBits ’ , 8 ,

’ StopBits ’ , 1) ;set ( s1 , ’ InputBu f f e rS i z e ’ ,2048) ;fopen ( s1 ) ;

% asynchronous modes1 . ReadAsyncMode = ’ cont inuous ’ ;

% loop to read datawhile ˜quit

i f ( s1 . BytesAva i lab le >= 128)% data proce s s ing code

endendfc lose ( s1 ) ;delete ( s1 ) ;clear s1 ;end

Er wordt dus eerst een object gedefinieerd die de kenmerken bevat van de seriële poort

waarmee er gecommuniceerd zal worden. Deze kenmerken omvatten de naam, de baudrate,

de parity, hoeveel databits en stopbits er zijn. Deze kenmerken moeten natuurlijk gelijk

zijn aan hoe de seriële interface werd geconfigureerd in de microcontroller. De grootte van

de inputbuffer kan ook worden ingesteld. Die moet voldoende groot zijn want eenmaal de

buffer vol is gaat er data verloren. Ook wordt ReadAsyncMode op continuous gezet, zodat

MATLAB continu de seriële poort pollt om te zien of nieuwe data beschikbaar is en deze

in de inputbuffer plaatst.

Dan kan er data worden uitgelezen, er wordt iedere keer gewacht tot er minstens 128

bytes in de inputbuffer aanwezig is, waarna deze uitgelezen en verwerkt kunnen worden.

3.3 Filter

Om een filter te ontwerpen is er informatie nodig over het signaal dat we wensen te de-

tecteren, met name de ademhaling van de baby. Enkele zaken liggen vast door de keuze

van de hardware, andere vloeien voort uit de kenmerken van de ademhaling van een baby.

De normale ademhalingsfrequentie van een baby jonger dan één jaar ligt tussen 30 en 40


ademhalingen per minuut, dit komt neer op een frequentie van 0, 5 Hz tot 0, 67 Hz. Het

commercieel systeem, Nanny Care[2], dat hetzelfde doel heeft maar op een andere manier

de ademhaling meet, slaat alarm als de ademhalingsfrequentie onder de 8 ademhalingen

per minuut zakt (0, 13 Hz) of als er 20 s geen ademhaling wordt gedetecteerd.

Omdat het signaal bijna altijd een DC component bevat en de gewenste informatie zich

zeer dicht bij DC bevindt in het spectrum, is een filter nodig. Deze filter moet signalen

met een frequentie van 0, 13 Hz doorlaten en tegelijk de DC component van het signaal

voldoende onderdrukken.

Om de nood aan een filter te illustreren volgen figuren van het spectrum van een

ongefilterde en gefilterde meting. In figuren 3.3 (a) en (b) zien we het spectrum van een

ongefilterde meting respectievelijk in hoge resolutie en lage resolutie. In het lage resolutie

spectrum zien we duidelijk dat de piek dicht bij 0, 2 Hz niet meer te onderscheiden valt van

de piek bij DC. In figuren 3.3 (c) en (d) kan men duidelijk de invloed zien van de filter.

3.3.1 Specificaties

De eigenschappen van het signaal dat gemeten moet worden werden hiervoor al genoemd.

Samen met andere factoren die voortvloeien uit de gekozen hardware, leggen deze de spe-

cificaties vast voor de filter. In wat volgt worden alle specificaties op een rijtje gezet.

Daar het te meten signaal een frequentie kan hebben van 0, 13 Hz, moet de doorlaat-

band op zijn minst op deze frequentie beginnen. Laten we deze beginnen op 0, 1 Hz

dan hebben we nog speelruimte.

Van een stopband kunnen we hier niet echt spreken maar de filter moet voldoende

onderdrukking hebben bij 0 Hz.

De sampling frequentie van het signaal is voor de gebruikte accelerometers 100 Hz.

Het is de bedoeling om de filter later in de microcontroller te implementeren dus is

het aangewezen om een type filter te kiezen die perfomant genoeg is zodat hij aan de

specificaties voldoet en tegelijk zo weinig mogelijk de microcontroller belast.

3.3.2 Wave Digital Filters (WDF)

WDF filters zijn gemodelleerd naar de klassieke (analoge) ladderfilters. Ze hebben goede

eigenschappen wat betreft de eisen in verband met de nauwkeurigheid van de coefficiënten,

het dynamisch bereik en zij hebben vooral een uitmuntende stabiliteit bij overflow- en


(a) (b)

(c) (d)

Figuur 3.1: Hoge resolutie (a) en lage resolutie (b) spectrum van ongefilterde meting, hoge

resolutie (c) en lage resolutie (d) spectrum van gefilterde meting

afrondingsverschijnselen[3]. Dit zijn juist de problemen die optreden bij het implementeren

van digitale filters in microcontrollers.

FIR en IIR filters kampen beide met nadelen wanneer deze moeten worden gëımplementeerd

in microcontrollers. FIR filters hebben een redelijk aantal vermenigvuldigingen nodig voor-

aleer een aanvaardbare onderdrukking wordt bekomen. Vermenigvuldigingen vragen reken-

kracht en als deze moeten uitgevoerd worden op een hoge sample frequentie dan kan dit

heel wat rekenkracht wegnemen. Dit geldt zeker voor steile filters waar het aantal nodige

vermenigvuldigingen snel oplopen. IIR filters aan de andere kant, hebben in verhouding

niet zoveel vermenigvuldigingen nodig om een vergelijkbaar resultaat te bekomen. Door

het recursief karakter van deze filters is de stabiliteit van de filter echter een probleem.


WDF filters maken kommaf met de beperkingen van zowel de FIR als de IIR filters.

Om een dergelijke filter te ontwerpen werd gebruik gemaakt van een toolbox[4] voor

MATLAB ontwikkeld door TU Delft en gratis ter beschikking. Met deze toolbox kan je

aan de hand van een GUI de specificaties ingeven van de filter en er wordt vervolgens een

filter ontworpen met deze specificaties.

Het resultaat is een filter opgebouwd uit elementaire blokken, vertragingselementen en

allpass blokken. De functie van een vertraginselement is duidelijk, echter wat een allpass

blok inhoudt minder. Figuur 3.3.2 toont het symbool samen met het onderliggende circuit.

Hierin stelt m de coefficiënt voor.

(a) (b)

Figuur 3.2: Een allpass element. (a) stelt het symbool voor en (b) stelt het interne circuit

voor het allpass element

Een implementatie in MATLAB van deze filter is gegeven in code fragment 3.2. Deze

filter voldoet echter niet aan de specificaties, toch geeft het een indruk wat het betekent

qua bewerkingen en complexiteit. Wegens tijdsgebrek werd dit soort filters niet verder

onderzocht en werden de functies van MATLAB gebruikt om de juiste filtering te realiseren.

Codefragment 3.2: MATLAB code voor de 5de-orde WDF filter

function x f i l t = w d f f i l t e r ( x )

% Implementation o f WDF f i l t e r

% F i l t e r c o e f f c i e n t sm1 = 0 .98257 ;m2 = −0.99967;m3 = 0 .99995 ;m4 = −0.99611;m5 = 0 .99994 ;

% f i l t e r c a l c u l a t i o n sfor i =1: length ( x )

a1 12 = a1 21 + ( a1 21 − x ( i ) ) *m1;


Figuur 3.3: 5de-orde WDF filter

3.4 FFT INHOUDSOPGAVE

a1 21 = ( a1 21 − x ( i ) ) *m1 + x( i ) ;a3 12 = a3 21 + ( a3 21 − a2 21 ) *m3;a3 21 = ( a3 21 − a2 21 ) *m3 + a2 21 ;a2 12 = a3 12 + ( a3 12 − a1 12 ) *m2;a2 21 = a1 12 + ( a3 12 − a1 12 ) *m2;a5 12 = a5 21 + ( a5 21 − a4 21 ) *m5;a5 21 = ( a5 21 − a4 21 ) *m5 + a4 21 ;a4 12 = a5 12 + ( a5 12 − x ( i ) ) *m4;a4 21 = ( a5 12 − x ( i ) ) *m4 + x( i ) ;x f i l t ( i ) = ( a4 12 − a2 12 ) /2 ;

end

3.4 FFT

Het spectrum wordt berekend om de ademhaling, die een repetitief signaal is met een

bepaalde frequentie waarbij de frequentie slechts traag veranderd in functie van de tijd, te

detecteren.

Bij het opstellen van de eisen voor de FFT zijn er twee kenmerken belangrijk: ten

eerste de gewenste resolutie en ten tweede de sample frequentie (fs). De accelerometer

spuwt meetwaarden uit met een frequentie van 100 Hz en de kleinste frequentie die we

willen kunnen detecteren is 0, 13 Hz, daaruit volgt:

N =fs

fkleinste=

100

0, 13= 769

We moeten dus de FFT minimaal in 769 punten berekenen om een verschil te maken

tussen DC en de laagst te detecteren frequentie. Afhankelijk van hoe de FFT berekend

wordt, moet N een macht van 2 zijn die het dichtst is bij 1024. Zo wordt dit al snel

een redelijke taak zeker met het oog op een implementatie in een microcontroller, waar

bijvoorbeeld complexe vermenigvuldigingen moeilijk zijn en de databreedte beperkt.

Om N te beperken kan ofwel de resolutie verminderen ofwel fs verminderen. Het

eerste is geen optie daar juist deze minimale ademhalingsfrequentie wenst gedetecteerd

te worden, fs verlagen kan wel, dit heeft echter tot gevolg dat de maximale frequentie

van het spectrum ook lager komt te liggen. Bij een fs van 100 Hz bedraagt de maximaal

te detecteren frequentie in het spectrum 50 Hz. De normale ademhalingsfrequentie van

babies ligt rond 0, 67 Hz, wordt wat marge genomen dan wordt de maximaal te detecteren

frequentie 2 Hz. We kunnen dus zonder zorgen fs verlagen. Als ook de filtering op deze

lagere fs gebeurt geeft dit ook positieve gevolgen voor de rekenintensiteit van de filter.


Het berekenen van een FFT is een rekenintensieve taak. Wanneer men beschikt over

veel rekenkracht is het minder belangrijk op welke manier de FFT berekend wordt. Het zal

hoogstens iets langer duren en meer energie kosten. Als men een FFT wenst te berekenen

op een microcontroller komt men beperkingen tegen die het moeilijk maken dit te realiseren:

seriële uitvoering van bewerkingen

floating-point bewerkingen vragen heel wat klokcycli

fixed-point bewerkingen zijn beperkt in bereik

beschikbaar geheugen is beperkt

Door de seriële uitvoering van de verschillende bewerkingen moeten tussenresultaten

worden bewaard. De nodige geheugenruimte loopt snel op naarmate N groter wordt. Er

kunnen floating-point berekeningen worden gemaakt met de MSP430 maar dit neemt een

groot aantal klokcycli in beslag. Doordat de bewerkingen snel oplopen naarmate N groter

wordt zou de tijd nodig om een FFT te berekenen lang zijn. Fixed-point bewerkingen

daarentegen vertonen een beperkt dynamisch bereik.

Dit is niet de eerste maal dat deze problemen werden ervaren. Doordat de FFT één

van de basisblokken is als men aan ’signal processing’ wil doen, zijn er heel wat algorit-

mes onderzocht die in meer of mindere mate geschikt zijn om te implementeren in een

microcontroller. Hier werden verschillende vlinderalgoritmes verder onderzocht.

3.4.1 Vlinder algoritmes

Radix-2 algoritme

In 1965 werd een artikel[5] gepubliceerd door James W. Cooley van IBM en John W. Tuc-

key van Princeton waarin een algoritme voorgesteld werd voor de berekening van complexe

fourier transformaties door machines. Het komt erop neer dat bij iedere stap van het algo-

ritme de N punts discrete fourier transformatie (DFT) wordt opgesplitst in twee kleinere

N/2 punts DFT’s. Daardoor wordt dit algoritme ook vaak het radix-2 algoritme genoemd.

Omdat het algoritme de FFT steeds halveert, moet N een macht van 2 zijn.

Wiskundig wordt het algoritme als volgt voorgesteld, startend met de formule voor de

DFT:

Xk =N−1∑n=0

xne− 2πj

Nnk met k = 0 . . . N − 1 (3.1)


Bij het radix-2 algoritme worden eest de even index nummers berekend, daarna de

oneven index nummers.

Xk =

N2−1∑

m=0

x2me− 2πj

N(2m)k +

N2−1∑

m=0

x2m+1e− 2πj

N(2m+1)k

=M−1∑m=0

x2me− 2πj

Mmk + e−

2πjNk

M−1∑m=0

x2m+1e− 2πj

Nmk

met

{M = N

2

k = 0 . . . N − 1

Er verschijnen dus twee kleinere DFT’s, wordt de DFT in de even punten (2m) El

genoemd en in de oneven punten (2m+ 1) Ol (met l = 0 . . .M −1) kan het geheel opnieuwgeschreven worden als volgt:

Xk =

{Ek + e

− 2πjNkOk als k < M

Ek−M − e− 2πjN (k−M)Ok−M als k ≥M(3.2)

Hierbij werd handig gebruik gemaakt van het feit dat Ek+M = Ek en Ok+M = Ok. De

twee kleinere DFT’s kan men terug op dezelfde manier opsplitsen tot er niet meer verder

gesplitst kan worden.

Er is nog een andere manier om hetzelfde af te leiden. Er wordt terug vertrokken van

vergelijking (3.1), maar we splitsen de som in twee.

Xk =

N2−1∑

n=0

xne− 2πj

Nnk +

N2−1∑

n=0

xn+N2e−

2πjN (n+

N2 )k

=

N2−1∑

n=0

[xn + xn+N

2e−πjk

]e−

2πjNnk

met k = 0 . . . N − 1

Dit kan nog wat compacter worden genoteerd als volgt:

Xk =

N2−1∑

n=0

[xn + (−1)kxn+N

2

]W nkN met

{k = 0 . . . N − 1

W nkN = e− 2πj

Nnk

(3.3)

Hierbij stelt W nkN de zogenaamde twiddle factors voor.


Dit algoritme kan ook grafisch worden voorgesteld, in figuur 3.4 is een voorbeeld te zien

waarbij N = 8. Het is ook meteen duidelijk waardoor dit algoritme ook vlinderalgoritme

genoemd wordt.

Figuur 3.4: Radix-2 vlinder voor N = 8

Radix-4 algoritme

Wordt de vergelijking (3.1) in plaats van in twee delen in vier delen gesplitst bekomen we

het radix-4 algoritme.

Xk =

N4−1∑

n=0

xne− 2πj

Nnk +

N4−1∑

n=0

xn+N4e−

2πjN (n+

N4 )k +

N4−1∑

n=0

xn+N2e−

2πjN (n+

N2 )k

+

N4−1∑

n=0

xn+ 3N4e−

2πjN (n+

3N4 )k

=

N4−1∑

n=0

[xn + xn+N

4e−

πj2k + xn+N

2eπjk + xn+ 3N

4e−

3πj2k]e−

2πjNnk

met k = 0 . . . N − 1

Verkort genoteerd geeft dit:

Xk =

N4−1∑

n=0

[xn + (−j)kxn+N

4+ (−1)kxn+N

2+ (j)kxn+ 3N

4

]W nkN (3.4)


Ook dit algoritme kan grafisch voorgesteld worden (figuur 3.5), er moet echter eerst een

radix-2 vlinder worden gebruikt om het op te delen in twee DFT’s met N = 4.

Figuur 3.5: Radix-4 vlinder voor N = 8

3.4.2 Gesplitste vlinder algoritmes

Een vlinderalgoritme kan ook worden gesplitst, hierbij worden de positieve eigenschap-

pen gecombineerd van verschillende vlinderalgoritmes. Deze aanpak helpt om de nodige

rekenkracht verder te verminderen.

Radix-2/4 algoritme

Zoals de titel al doet vermoeden wordt hier het radix-2 en het radix-4 algoritme gecombi-

neerd. Daar bij een radix-2 algoritme de oneven indexen vermenigvuldigd moeten worden

met twiddle factors, worden de oneven indexen berekend met het radix-4 algoritme waar

minder van deze vermenigvuldigingen aanwezig zijn.

In formule vorm ziet dit er zo uit:


X2k =

N2−1∑

n=0

[xn + xn+N

2

]W 2nkN (3.5)

X4k′+1 =

N4−1∑

n=0

[xn − xn+N

2− j

(xn+N

4− xn+ 3N

4

)]W 4nk

′

N WnN (3.6)

X4k′+3 =

N4−1∑

n=0

[xn − xn+N

2+ j

(xn+N

4− xn+ 3N

4

)]W 4nk

′

N W3nN (3.7)

Waarbij k = 0 . . . N2− 1 en k′ = 0 . . . N

4− 1. Figuur 3.6 stelt dit algoritme grafisch voor.

Figuur 3.6: Radix-2/4 vlinder

Radix-2/8 algoritme

Er kan nog een stap verder worden gegaan door het radix-2 en het radix-8 algoritme

samen te nemen. Het radix-2 algoritme neemt terug de even indexen voor zijn rekening.

Het radix-8 algoritme wordt aangewend om de oneven indexen te berekenen.

De formules voor dit algoritme zijn de volgende:


X2k =

N2−1∑

n=0

[xn + xn+N

2

]W 2nkN (3.8)

X8k′+1 =

N8−1∑

n=0

[[xn − xn+N

2− j

(xn+N

4− xn+ 3N

4

)](3.9)

+WN8N

[xn+N

8− xn+ 5N

8− j

(xn+ 3N

8− xn+ 7N

8

)]]W 8nk

′

N WnN (3.10)

X8k′+5 =

N8−1∑

n=0

[[xn − xn+N

2− j

(xn+N

4− xn+ 3N

4

)](3.11)

−WN8N

[xn+N

8− xn+ 5N

8− j

(xn+ 3N

8− xn+ 7N

8

)]]W 8nk

′

N W5nN (3.12)

X8k′+3 =

N8−1∑

n=0

[[xn − xn+N

2+ j

(xn+N

4− xn+ 3N

4

)](3.13)

+W3N8

N

[xn+N

8− xn+ 5N

8+ j

(xn+ 3N

8− xn+ 7N

8

)]]W 8nk

′

N W3nN (3.14)

X8k′+7 =

N8−1∑

n=0

[[xn − xn+N

2+ j

(xn+N

4− xn+ 3N

4

)](3.15)

−W3N8

N

[xn+N

8− xn+ 5N

8+ j

(xn+ 3N

8− xn+ 7N

8

)]]W 8nk

′

N W7nN (3.16)

Waarbij k = 0 . . . N2− 1 en k′ = 0 . . . N

8− 1. De grafische voorstelling van dit algoritme is

te zien in figuur 3.7.

Radix-2/4/8 algoritme[6]

De voorgaande twee algoritmes hebben als nadeel dat ze een soort van L-vorm vertonen,

hierdoor worden onregelmatige vormen bekomen in vergelijking met het gebruik van een

vast radix algoritme (bv. radix-2) of een combinatie van vaste radix algoritmes (bv. radix-

2/radix-4). Daardoor wordt het moeilijker om het efficient in hardware pipeline structuren

te implementeren. Voor deze toepassing is dit argument niet echt van toepassing maar er

kan heel wat winst worden geboekt op de omvang van de source code. Dit maakt vooral dat

er minder kans op fouten optreden en het minder beslag legt op het programmageheugen

moest dit een beperkende factor zijn.

Om dit te verhelpen kan men een radix-2/8 vlinder combineren met een radix-2/4 en

radix-2 vlinder. Hierdoor bekomen we terug een regelmatige structuur, te zien in figuur

3.8. Dit kan ook in blokvorm voorgesteld worden zoals in figuur 3.9.


Figuur 3.7: Radix-2/8 vlinder

Figuur 3.8: Radix-2/4/8 vlinder

Figuur 3.9: Radix-2/4/8 blok


Om een idee te hebben welke besparingen er mogelijk gemaakt zijn door het radix-2/4/8

algoritme te gebruiken is er een overzicht van de complexe vermenigvuldigingen (twiddle

factors) in tabel 3.1. Hierin kan men duidelijk zien dat er heel wat winst geboekt wordt

met het radix-2/4/8 algoritme.

N = 8n radix-2 radix-4 radix-2/4 radix-2/4/8

8 2 - 2 0

64 98 76 72 48

512 1538 - 1082 824

4096 18434 13996 12774 10168

Tabel 3.1: Overzicht complexe vermenigvuldigingen bij verschillende radix algoritmes[6]

3.4.3 256 punts FFT

Wordt fs verlaagd tot 12, 5 Hz dan volstaat een 256 punts FFT om toch nog in staat te

zijn 8 ademhalingen per minuut te detecteren. Dit betekent dat we met het radix-2/4/8

algoritme eerst een radix-4 vlinder nodig hebben. Dit verdeelt de 256 punts FFT in 4

kleinere FFT’s van 64 punten. Elk van deze 64 punts FFT kan worden onderverdeeld in

acht 8 punts FFT’s met het radix-2/4/8 algoritme. Uiteindelijk moeten de kleine 8 punts

FFT’s nog eens berekend worden met het radix-2/4/8 algoritme. Een blokschema van deze

256 punts FFT kan men zien in figuur 3.10.

De volgende stap is deze FFT in MATLAB code gieten, hiervoor werd de omgekeer-

de weg gevolgd. Beginnen met een elementaire radix-2/4/8 vlinder en dan stelselmatig

opbouwen tot de uiteindelijke 256 punts FFT bereikt wordt.

Het code fragment 3.3 toont de MATLAB code voor een elementaire radix-2/4/8 vlin-

der. Hierbij wordt het berekend in stappen zoals ze ook in figuur 3.8 aangegeven worden,

waarbij a en b de tussenresultaten vormen.

Een volgende stap in de richting van de 256 punts FFT is de 64 punts radix-2/4/8

vlinder, de MATLAB code hiervan is gegeven in code fragment 3.4. Hierin vindt men

duidelijk de structuur terug van de elementaire radix-2/4/8 code. Het belangrijkste verschil

zit in de vermenigvuldiging met de twiddle factoren in de laatste stap. Deze code wordt

in een for-lus 8 maal uitgevoerd juist om de FFT in deze 64 punten te berekenen.


Figuur 3.10: 256 punts FFT met het radix-2/4/8 algoritme


Codefragment 3.3: MATLAB code voor een elementaire radix-2/4/8 vlinder

function out = p8 rad i x 2 4 8 ( in )% Elementary 8 po in t radix −2/4/8 b u t t e r f l ya (1 ) = in (1 ) + in (5 ) ;a (2 ) = in (2 ) + in (6 ) ;a (3 ) = in (3 ) + in (7 ) ;a (4 ) = in (4 ) + in (8 ) ;a (5 ) = in (1 ) − in (5 ) ;a (6 ) = in (2 ) − in (6 ) ;a (7 ) = −j *( in (3 ) − in (7 ) ) ;a (8 ) = −j *( in (4 ) − in (8 ) ) ;

b (1 ) = a (1) + a (3) ;b (2 ) = a (2) + a (4) ;b (3 ) = a (1) − a (3 ) ;b (4 ) = −j *( a (2 ) − a (4 ) ) ;

b (5 ) = a (5) + a (7) ;b (6 ) = sqrt (2 ) /2*(1− j ) *( a (6 ) + a (8) ) ;b (7 ) = a (5) − a (7 ) ;b (8 ) = −sqrt (2 ) /2*(1+ j ) *( a (6 ) − a (8 ) ) ;

out (1 ) = b (1) + b (2) ;out (2 ) = b (1) − b (2) ;

out (3 ) = b (3) + b (4) ;out (4 ) = b (3) − b (4) ;

out (5 ) = b (5) + b (6) ;out (6 ) = b (5) − b (6) ;

out (7 ) = b (7) + b (8) ;out (8 ) = b (7) − b (8) ;end


Codefragment 3.4: MATLAB code voor een 64 punts radix-2/4/8 vlinder

function out = p64 rad i x 2 4 8 ( in )% 64 po in t radix −2/4/8 b u t t e r f l yfor n=1:8

a (n) = in (n) + in (32+n) ;a(8+n) = in (8+n) + in (40+n) ;a(16+n) = in (16+n) + in (48+n) ;a(24+n) = in (24+n) + in (56+n) ;a(32+n) = in (n) − in (32+n) ;a(40+n) = in (8+n) − in (40+n) ;a(48+n) = −j *( in (16+n) − in (48+n) ) ;a(56+n) = −j *( in (24+n) − in (56+n) ) ;

b (n) = a (n) + a(16+n) ;b(8+n) = a(8+n) + a(24+n) ;b(16+n) = a (n) − a(16+n) ;b(24+n) = −j *( a(8+n) − a(24+n) ) ;

b(32+n) = a(32+n) + a(48+n) ;b(40+n) = sqrt (2 ) /2*(1− j ) *( a(40+n) + a(56+n) ) ;b(48+n) = a(32+n) − a(48+n) ;b(56+n) = −sqrt (2 ) /2*(1+ j ) *( a(40+n) − a(56+n) ) ;

out (n) = b(n) + b(8+n) ;out(8+n) =(b(n) − b(8+n) ) *exp(− j *2*pi *(n−1)/16) ;

out (16+n) = (b(16+n) + b(24+n) ) *exp(− j *2*pi *(n−1)/32) ;out (24+n) = (b(16+n) − b(24+n) ) *exp(− j *2*pi *3*(n−1)/32) ;


out (48+n) = (b(48+n) + b(56+n) ) *exp(− j *2*pi *3*(n−1)/64) ;out (56+n) = (b(48+n) − b(56+n) ) *exp(− j *2*pi *7*(n−1)/64) ;

end


Er rest nog één stap, namelijk de radix-4 vlinder om de 256 punts FFT op te splitsen

in vier 64 punts FFT’s. De MATLAB code voor deze stap is na te lezen in code frag-

ment 3.5, ook hier kan men de vlinderstructuur terugvinden. Er moet hier ook worden

vermenigvuldigt met twiddle factoren.

Codefragment 3.5: MATLAB code voor een 256 punts radix-4 vlinder

function [ out ] = p256 rad ix 4 ( in )% 256 po in t s radix−4 b u t t e r f l yfor n=1:64

out (n) = in (n) + in (n+64) + in (n+128) + in (n+192) ;out (n+64) = ( in (n) − j * in (n+64) − in (n+128) + j * in (n+192) ) *exp(− j *2*pi *(

n−1)/256) ;out (n+128) = ( in (n) − in (n+64) + in (n+128) − in (n+192) ) *exp(− j *2*pi *2*(n−1)/256) ;

out (n+192) = ( in (n) + j * in (n+64) − in (n+128) − j * in (n+192) ) *exp(− j *2*pi*3*(n−1)/256) ;

end

Deze verschillende vlinders moeten gecombineerd worden om de volledige FFT te kun-

nen berekenen, dit wordt gedaan p256_fft.m wat samen met de volledige MATLAB code

te vinden is in appendix A.1.2. Na de uitvoering van de vlinders en de FFT in wezen be-

rekend is moeten de bekomen waarden nog in de juiste volgorde worden gezet. Dit wordt

gedaan aan de hand van arrange_output.m.

Prestaties van het algoritme

Om de prestaties van het algoritme te kunnen evalueren werd een testbench geschreven

(p256_fft_tb.m). Hierin werd random data gegenereerd en vervolgens werd het spectrum

berekend met zowel het radix-2/4/8 algoritme als met de FFT functie van MATLAB zelf.

Beide resultaten werden van elkaar afgetrokken zodat enkel de fout overbleef. Vervolgens

werd de verhouding tussen het spectrum en de fout berekend in dB. Dit werd 100 maal

herhaald en het resultaat is te zien in figuur 3.11. De verhouding ligt rond 310 dB wat laat

besluiten dat het verschil nagenoeg nihil is.

Deze testbench kan ook in een later stadium worden gebruikt om de prestatie van de

gekwantiseerde code te evalueren. Er is echter nog niet tot het kwantiseren van de code

gekomen.

3.5 Uiteindelijke analyse INHOUDSOPGAVE

Figuur 3.11: Verhouding van de fout op het radix-2/4/8 algoritme tot de MATLAB FFT

functie

3.5 Uiteindelijke analyse

In de voorgaande punten werden de verschillende onderdelen voor het analyseren van de

gegevens met MATLAB overlopen. Deze moeten allemaal aan elkaar gelinkt worden om

de uiteindelijke analyse uit te kunnen voeren. Dit werd in twee stappen gedaan: namelijk

de data binnen nemen en opslaan middels de geschreven seriële interface in MATLAB en

vervolgens deze bewaarde data analyseren met een script.

De metingen werden uitgevoerd op een testpersoon, dit was een volwassen persoon.

Er werd echter aangenomen dat deze metingen ook voor babies representatief zijn. De

bewegingen die de borst van een baby maakt zijn kleiner, maar het ademhalingsritme

hoger wat als gevolg moet hebben dat de gemeten versnellingen van de bewegingen zelfs

hoger zijn.

In de volgende secties zijn representatieve metingen geanalyseerd in verschillende posi-

ties. Een baby kan zowel op de rug als op de borst slapen, hoewel het laatste niet wordt

aangeraden. De hardware voorziet de mogelijkheid om twee sensoren aan te sluiten, één

op de borst en één op de rug. Zodat in alle omstandigheden minstens één sensor vrij kan

bewegen om de ademhaling te detecteren.


3.5.1 Liggend op de rug met sensor op de borst

Bij deze meting bedroeg het ademhalingsritme ongeveer 16 ademhalingen per minuut wat

neerkomt op 0, 26 Hz. In figuur 3.12 ziet men bovenaan hoe de meting werd binnengenomen

via de seriële interface en onderaan dezelfde meting maar met het DC niveau verwijderd. De

gefilterde meting is wat korter omdat het begin van het gefilterde signaal werd verwijderd.

Het signaal werd slechts geselecteerd waar de filter al min of meer tot rust was gekomen.

Figuur 3.12: Meting en gefilterde meting, liggend op de rug met sensor op de borst

Figuur 3.13 toont een hoge resolutie FFT van de gefilterde meting. Daarnaast wordt

diezelfde FFT nogmaals getoond, beperkt tot het gebied van interesse (0 Hz tot 2 Hz).

Hierin is duidelijk een piek te zien die iets boven de 0, 2 Hz ligt. Het is dus bevestigd dat

de ademhaling kan worden gedetecteerd met accelerometers.

De ademhaling moet worden gedetecteerd en er kan niet lang worden gewacht op genoeg

data om een hoge resolutie FFT te berekenen. Aan een sample frequentie van 25 Hz duurt

het al snel een minuut om een FFT te kunnen berekenen van 1024 punten. Tegen die tijd

moet er reeds alarm geslagen worden indien er geen ademhaling gedetecteerd wordt. Een

256 punts FFT kan worden uitgerekend om de 10 s. Hierbij kan eventueel worden overlapt

en om de 5 s de 256 punts FFT worden berekend. Op deze manier wordt het wel mogelijk

om na een tiental seconden alarm te slaan als er geen ademhaling wordt gedetecteerd.


(a) (b)

Figuur 3.13: Hoge resolutie FFT (a) en tot 2 Hz (b), liggend op de rug met sensor op de

borst

Figuur 3.14 toont vier van deze kleinere 256 punts FFT’s berekend met het radix-2/4/8

algoritme op verschillende tijdstippen in de gefilterde meting. Er duikt telkens een piek op

die rond de 0, 2 Hz gelegen is. Het is ook telkens de grootste zodat deze ook makkelijk te

detecteren valt.

3.5.2 Liggend op de borst met de sensor op de rug

Ook als de baby op de borst ligt moet de ademhaling met een sensor op de rug kunnen wor-

den gedetecteerd. Dit is minder vanzelfsprekend daar de bewegingen minder uitgesproken

zijn. Hier werden ongeveer 15 ademhalingen per minuut geregistreerd wat een frequentie

van 0, 25 Hz met zich meebrengt.

Figuur 3.15 toont terug de meting en de gefilterde meting in het tijdsdomein.

In de hoge resolutie FFT (figuur 3.16) kan men terug een duidelijke piek vinden rond

0, 2 Hz. Er kan dus opnieuw vanuit worden gegaan dat de ademhaling te detecteren valt

wanneer men op de borst ligt met een sensor op de rug geplaatst.

Ook hier werden vier kleinere FFT’s berekend (figuur 3.17). Terug zijn er pieken waar

te nemen rond de 0, 2 Hz. In twee van de vier FFT’s duiken er nog pieken op bij andere

frequenties, namelijk bij deelfiguren (a) en (g). Bij de laatste is de piek bij de ademhaling

enkel de grootste wanneer alleen het gebied tussen 0 Hz en 2 Hz beschouwd wordt.

Het blijkt dus wat moeilijker te zijn om in deze positie de ademhaling te detecteren.


(a) (b)

(c) (d)

(e) (f)

(g) (h)

Figuur 3.14: 256 punts FFT’s op verschillende plaatsen met overeenkomstige beperkte

bereiken tot 2 hertz


Figuur 3.15: Meting en gefilterde meting, liggend op de borst met sensor op de rug

(a) (b)

Figuur 3.16: Hoge resolutie FFT (a) en tot 2 Hz (b), liggend op de borst met sensor op de

rug


(a) (b)

(c) (d)

(e) (f)

(g) (h)

Figuur 3.17: 256 punts FFT’s op verschillende plaatsen met overeenkomstige beperkte

bereiken tot 2 hertz


3.5.3 Liggend op de rug met sensor op de borst zonder te ademen

Het is ook belangrijk te weten of het niet ademen ook te detecteren valt. Deze meting kan

uiteraard geen minuten duren en is dan ook wat korter.

De meting samen met de gefilterde meting worden weergegeven in figuur 3.18.

Figuur 3.18: Meting en gefilterde meting, liggend op de rug met sensor op de borst zonder

te ademen

Een hoge resolutie FFT van de meting wordt gegeven in figuur 3.19(a). Hierin is een

piek waar te nemen maar deze bevindt zich onder de 0, 1 Hz. In deze situatie zou dus

alarm worden geslagen.


(a) (b)

Figuur 3.19: Hoge resolutie FFT (a) en tot 2 Hz (b), liggend op de rug met sensor op de

borst zonder te ademenen

FIRMWARE INHOUDSOPGAVE

Hoofdstuk 4

Firmware

4.1 Ontwikkelomgeving

Er is een ontwikkelomgeving nodig om de code voor de microcontroller te compileren en

vervolgens de microcontroller met deze gecompileerde code te programmeren. De gekozen

ontwikkelomgeving hier gebruikt betreft de open source mspgcc[7]. Deze ontwikkelom-

geving is zowel beschikbaar voor Linux als voor Windows en is gebaseerd op de GNU

gcc compiler. Naast de compiler bevat de ontwikkelomgeving ook tools om de code te

debuggen.

Deze ontwikkelomgeving biedt een volwaardig alternatief voor de IAR Kickstart ontwik-

kelomgeving, die weliswaar ook gratis beschikbaar is. Er is echter wel een licentie nodig als

de C-source code groter is dan 1kB. Deze ontwikkelomgeving is trouwens enkel beschikbaar

voor Windows.

4.2 Interface met de sensor

De gekozen sensor LIS302DL ondersteunt zowel de I2C als de SPI communicatie protocol-

len. Hier werd gekozen om d.m.v. het SPI protocol met de sensor te communiceren. Deze

interface laat toe om met een maximum klokfrequentie van 10 MHz te communiceren met

de sensor. De I2C interface daarentegen heeft als maximum klokfrequentie 400 kHz. De

opzet van het SPI protocol is ook heel wat eenvoudiger dan het I2C protocol.

De MSP430F149 heeft twee configureerbare seriële interfaces (USART’s) die zowel SPI

als asynchrone seriële communicatie aankan. Zodoende is het wel verplicht om via het SPI

protocol te communiceren met de sensor als deze dedicated hardware interface gebruikt

wil worden. Dit moet echter geconfigureerd worden. Het code fragment 4.1 toont hoe dit

4.2 Interface met de sensor INHOUDSOPGAVE

verwezenlijkt wordt.

Codefragment 4.1: C code voor de configuratie van de SPI interface

void s p i s e t up (void ) {P3SEL |= BIT1 + BIT2 + BIT3 ; // Setup P3 fo r SPI modeP3OUT |= BIT4 ; // Setup P3 .4 f o r enab l ing s l a v eP3DIR |= BIT4 + BIT3 + BIT1 ; // P3 .1 ,3 ,4 i s outputU0CTL |= CHAR + SYNC + MM; // 8− b i t Master SPI modeU0TCTL = CKPL + SSEL SMCLK + STC; // Po lar i t y , SMCLK, 3−wireU0BR0 = BIT1 ; // SPICLK=SMCLK/2U0BR1 = 0x00 ;U0MCTL = 0x00 ;ME1 |= USPIE0 ; // SPI module enab ledUCTL0 &= ˜SWRST; // I n i t i a l i z e SPI s t a t e machine

}

Eerst worden de nodige bits gezet in de poortregisters om de microcontroller te ver-

tellen dat deze verbonden moeten worden met de configureerbare seriële interface en niet

moeten worden gebruikt als gewone I/O poorten. Alsook welke poorten als ouput en input

geconfigureerd worden. Daarna wordt de configureerbare seriële interface geconfigureerd

als een SPI interface. Vervolgens wordt deze gëınitialiseerd en is ze klaar om te gebruiken.

Codefragment 4.2: C code voor het lezen van de SPI interface

signed char s p i r e ad (char addr ) {signed char data ;P3OUT &= ˜BIT4 ; // Enable s l a v eIFG1 &= ˜URXIFG0; // Clear f l a gTXBUF0 = LIS302DL READ + addr ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = 0 ; // Dummy wr i t e so we can read datawhile ( ! ( IFG1&URXIFG0) ) ; // Wait f o r RX to f i n i s hdata = RXBUF0;P3OUT |= BIT4 ; // Disab l e s l a v ereturn data ;

}

Data kan via de SPI interface worden gelezen met behulp van codefragment 4.2. Om

een waarde uit te lezen wordt de sensor geactiveerd en wordt het betreffende adres van de

informatie naar de microcontroller gestuurd. Daarvoor hoeft enkel het adres en de leesbit

in de zendbuffer worden geplaatst. Er wordt gewacht tot de verzending voltooid is en dan

4.3 Interface met de computer INHOUDSOPGAVE

wordt er een dummybyte in de zendbuffer geplaatst om het antwoord van de sensor binnen

te kunnen klokken. Als het antwoord ontvangen is wordt het doorgegeven.

Codefragment 4.3: C code voor het schrijven naar de SPI interface

void s p i w r i t e (char addr , char va l ) {P3OUT &= ˜BIT4 ; // Enable s l a v eIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = LIS302DL WRITE + addr ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = val ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hP3OUT |= BIT4 ; // Disab l e s l a v e

}

Het schrijven van data via de SPI interface gebeurt met codefragment 4.3. Schrijven

gebeurt op dezelfde manier als lezen. Er wordt een adres en schrijfbit in de zendbuffer

geplaatst en gewacht tot de verzending voltooid is. Dan wordt de te schrijven data in de

zendbuffer geplaatst en op zijn beurt verzonden naar de sensor.

4.3 Interface met de computer

De communicatie met de computer gebeurt op een gelijkaardige manier. Hiervoor wordt de

tweede configureerbare seriële interface gebruikt. Deze interface wordt hier enkel gebruikt

om data weg te schrijven naar de computer en niet omgekeerd.

Ook hier moet de interface eerst worden geconfigureerd. Codefragment 4.4 verwezenlijkt

dit.

Codefragment 4.4: C code voor de configuratie van de interface met de computer

void uar t s e tup (void ) {P3SEL |= 0xC0 ; // P3 .6 ,7 = USART1 TXD/RXDME2 |= UTXE1 + URXE1; // Enable USART1 TXD/RXDUCTL1 |= CHAR; // 8− b i t charac t e rUTCTL1 |= SSEL0 ; // UCLK = ACLKUBR01 = 0x03 ; // 32k/9600 − 3.41UBR11 = 0x00 ; //UMCTL1 = 0x4A ; // ModulationUCTL1 &= ˜SWRST; // I n i t i a l i z e USART s t a t e machine

}

4.4 Hoofd programma INHOUDSOPGAVE

De betreffende poorten moeten opnieuw op de juiste manier worden ingesteld. Er wordt

een klok geselecteerd en dan wordt via delers de juiste baudrate ingesteld. Daarna wordt

de interface gëınitialiseerd en is deze klaar voor gebruik.

Codefragment 4.5: C code voor het schrijven naar de interface met de computer

void ua r t wr i t e (char va l ) {while ( ! ( IFG2 & UTXIFG1) ) ; // USART1 TX bu f f e r ready?TXBUF1 = val ; // va l to TXBUF1

}

Data wegschrijven via de interface kan met codefragment 4.5. Er wordt eerst nagegaan

en eventueel gewacht tot data in de zendbuffer kan worden geplaatst. Het wordt vervolgens

in de buffer geplaatst en verzonden via de interface naar de computer.

4.4 Hoofd programma

Het hoofd programma doet eigenlijk niets meer dan de data van de sensor uitlezen en

vervolgens doorzenden naar de computer. De main loop van het programma is gegeven in

codefragment 4.6.

De beide interfaces worden eerst geconfigureerd waarna de sensor wordt ingesteld. Er

wordt meegegeven dat de sensor een interrupt op een poort van de microcontroller genereert

als er een nieuwe meetwaarde ter beschikking is. Vervolgens verkeert de microcontroller in

een oneindige lus waarbij hij controleert of er een nieuwe meetwaarde klaar staat en deze

uitleest als dit zo is. Zodra 4 meetwaarden uitgelezen zijn worden ze bij elkaar opgeteld en

dit resultaat wordt doorgestuurd naar de computer.

De sensor heeft meetwaarden klaar met een frequentie van 100 Hz; door 4 meetwaarden

op te tellen en dan pas door te sturen is de sample frequentie verminderd tot 25 Hz.

De volledige source code is te vinden in bijlage A.2.

4.4 Hoofd programma INHOUDSOPGAVE

Codefragment 4.6: C code voor de main loop van het programma

int main (void ) {uar t s e tup ( ) ;s p i s e t up ( ) ;// Conf igure LIS302DL : i n t e r r u p t on INT1 when data i s readys p i w r i t e (LIS302DL REG CTRL3 , LIS302DL INTMODE DATA READY) ;// Enable Z−ax i s and enab l e dev i c es p i w r i t e (LIS302DL REG CTRL1 , LIS302DL CTRL1 PD + LIS302DL CTRL1 Zen

) ;while (1 ) {

i f ( i n t a c c da t a == 1) {outz [ i ] = sp i r e ad (LIS302DL REG OUT Z) ;i f ( i == 3) {

i = 0 ;mz = 0 ;calc mean ( ) ;u a r t w r i t e i n t (mz) ;

}else {

i++;}i n t a c c da t a = 0 ;

}}

}

Codefragment 4.7: C code voor de interrupt afhandeling

i n t e r r up t (PORT1 VECTOR) ge t a c c da ta ( ) {i n t a c c da t a = 1 ;P1IFG &= ˜BIT3 ; // Clear P1 .3 i n t e r r u p t f l a g

}

Codefragment 4.8: C code voor het berekenen van het gemiddelde

void calc mean (void ) {char j ;for ( j =0; j

BESLUIT INHOUDSOPGAVE

Hoofdstuk 5

Besluit

In dit werk werd een eerste stap gezet in de ontwikkeling van een ademhalingssensor op ba-

sis van accelerometers. Er werd een hardwareplatform ontwikkeld dat universeel is en niet

enkel beperkt is tot een ademhalingssensor. Dit neemt niet weg dat het met deze bedoeling

werd ontwikkeld. Er werd aangetoond dat het wel degelijk mogelijk is om met accelerome-

ters de ademhaling te detecteren. Een eerste stap in de richting van implementatie van de

algoritmes in de microcontroller werd gezet.

Een proof-of-concept werd afgeleverd, waarmee meteen ook wordt aangegeven dat dit

niet het einde is van de ontwikkeling van deze ademhalingssensor..Het is veeleer een begin.

Het hardware deel staat min of meer op punt, echter op algoritmisch vlak kan er nog veel

verder worden gewerkt. De aanzet werd hier gegeven voor sommige delen, zoals de FFT.

Er rest echter nog heel wat. Het radix-2/4/8 algoritme, hier uitgewerkt, kan het spectrum

berekenen van een reeks complexe getallen. De data waarvan in deze toepassing het spec-

trum berekend wordt zijn echter reëel en er is nog heel wat ruimte om de complexiteit te

verlagen. Er is ook een beperkt deel van dit spectrum waar de gewenste informatie zich

bevindt, dit kenmerk werd niet aangewend om de complexiteit nog verder terug te drin-

gen. Vooraleer het te implementeren valt in de microcontroller moet er ook een kwantisatie

gedaan worden van de algoritmes ontwikkeld in MATLAB.

Voor de filter werden WDF filters onderzocht, maar het is niet gelukt om uit te maken

of deze nu wel of niet geschikt zijn. Slechts een 3de en 5de-orde filter werden in MATLAB

code gegoten en deze bleken niet performant genoeg te zijn. Het moet verder onderzocht

worden of deze wel geschikt zijn voor deze applicatie.

Als algemeen besluit kan gesteld worden dat werd aangetoond dat op basis van acce-

lerometers de ademhaling kan worden gedetecteerd. Om tot een betrouwbare detectie te

komen zijn de eerste stappen gezet maar is nog een lange weg te gaan.

SOURCE CODE INHOUDSOPGAVE

Bijlage A

Source code

A.1 MATLAB source code

A.1.1 Seriële interface

MATLAB code voor de seriële interface: serial_interface.m

function s e r i a l i n t e r f a c e ( )

% Opens a s e r i a l communication o b j e c ts1=s e r i a l ( ’ /dev/ttyUSB0 ’ , ’BaudRate ’ , 9600 , ’ Par i ty ’ , ’ none ’ , ’ DataBits ’ , 8 , ’

StopBits ’ , 1) ;set ( s1 , ’ InputBu f f e rS i z e ’ ,2048) ; % in i=512fopen ( s1 ) ;

% asynchronous modes1 . ReadAsyncMode = ’ cont inuous ’ ;

% s e t t i n g up v a r i a b l e s ho l d ing the datadata = zeros (15000 ,1) ; % ho ld s a l l raw dataz = zeros (32 ,1 ) ; % incoming raw data (25Hz)bu f z = zeros (256 ,1 ) ; % bu f f e r raw data

% s e t t i n g up f i g u r eh = f igure ;set (h , ’ KeyPressFcn ’ , @keyHandler ) ;handleZ = plot ( z ) ;t i t l e ( ’ Received data Fs=25Hz ’ ) ;

% reading data from s e r i a l i n t e r f a c e

A.1 MATLAB source code INHOUDSOPGAVE

max index = 0 ;quit = 0 ;i =0;k=0;while ˜quit

i f ( s1 . BytesAva i lab le >= 64)z ( : , 1 ) = fread ( s1 , 3 2 , ’ i n t16 ’ ) ;data ( ( k*32+1) : ( ( k+1)*32) ,1 )=z ;k=k+1;i f ( i


elsea (1 ) = in (1 ) + in (5 ) ;a (2 ) = in (2 ) + in (6 ) ;a (3 ) = in (3 ) + in (7 ) ;a (4 ) = in (4 ) + in (8 ) ;a (5 ) = in (1 ) − in (5 ) ;a (6 ) = in (2 ) − in (6 ) ;a (7 ) = −j *( in (3 ) − in (7 ) ) ;a (8 ) = −j *( in (4 ) − in (8 ) ) ;

b (1 ) = a (1) + a (3) ;b (2 ) = a (2) + a (4) ;b (3 ) = a (1) − a (3 ) ;b (4 ) = −j *( a (2 ) − a (4 ) ) ;

b (5 ) = a (5) + a (7) ;b (6 ) = sqrt (2 ) /2*(1− j ) *( a (6 ) + a (8) ) ;b (7 ) = a (5) − a (7 ) ;b (8 ) = −sqrt (2 ) /2*(1+ j ) *( a (6 ) − a (8 ) ) ;

out (1 ) = b (1) + b (2) ;out (2 ) = b (1) − b (2) ;

out (3 ) = b (3) + b (4) ;out (4 ) = b (3) − b (4) ;

out (5 ) = b (5) + b (6) ;out (6 ) = b (5) − b (6) ;

out (7 ) = b (7) + b (8) ;out (8 ) = b (7) − b (8) ;

end

MATLAB code voor de 64 punts radix-2/4/8 vlinder: p64_radix_2_4_8.m

function out = p64 rad i x 2 4 8 ( in )

% 64 po in t radix −2/4/8 b u t t e r f l y

a = zeros (1 , 64 ) ;b = zeros (1 , 64 ) ;out = zeros (1 , 64 ) ;i f ( length ( in ) ˜= 64)

disp ( ’Wrong input l ength ! Should be 64 po in t s ’ ) ;


elsefor n=1:8

a (n) = in (n) + in (32+n) ;a(8+n) = in (8+n) + in (40+n) ;a(16+n) = in (16+n) + in (48+n) ;a(24+n) = in (24+n) + in (56+n) ;a(32+n) = in (n) − in (32+n) ;a(40+n) = in (8+n) − in (40+n) ;a(48+n) = −j *( in (16+n) − in (48+n) ) ;a(56+n) = −j *( in (24+n) − in (56+n) ) ;

b (n) = a (n) + a(16+n) ;b(8+n) = a(8+n) + a(24+n) ;b(16+n) = a (n) − a(16+n) ;b(24+n) = −j *( a(8+n) − a(24+n) ) ;

b(32+n) = a(32+n) + a(48+n) ;b(40+n) = sqrt (2 ) /2*(1− j ) *( a(40+n) + a(56+n) ) ;b(48+n) = a(32+n) − a(48+n) ;b(56+n) = −sqrt (2 ) /2*(1+ j ) *( a(40+n) − a(56+n) ) ;

out (n) = b(n) + b(8+n) ;out(8+n) =(b(n) − b(8+n) ) *exp(− j *2*pi *(n−1)/16) ;



out (48+n) = (b(48+n) + b(56+n) ) *exp(− j *2*pi *3*(n−1)/64) ;out (56+n) = (b(48+n) − b(56+n) ) *exp(− j *2*pi *7*(n−1)/64) ;

endend

MATLAB code voor de 256 punts radix-4 vlinder: p256_radix_4.m

function [ out ] = p256 rad ix 4 ( in )

% 256 punts radix−4 b u t t e r f l y

i f ( length ( in ) ˜= 256)disp ( ’Wrong input l ength ! Should be 256 po in t s ’ ) ;return ;


elsefor n=1:64

out (n) = in (n) + in (n+64) + in (n+128) + in (n+192) ;out (n+64) = ( in (n) − j * in (n+64) − in (n+128) + j * in (n+192) ) *exp(− j *2*

pi *(n−1)/256) ;out (n+128) = ( in (n) − in (n+64) + in (n+128) − in (n+192) ) *exp(− j *2*pi

*2*(n−1)/256) ;out (n+192) = ( in (n) + j * in (n+64) − in (n+128) − j * in (n+192) ) *exp(− j

*2*pi *3*(n−1)/256) ;end

end

MATLAB code om de output te herschikken: arrange_output.m

function out = arrange output ( in ) ;

% Arranges de output a f t e r the l a s t radix −2/4/8 s t a ge

index1 = [0 8 4 12 1 9 5 13 2 10 6 14 3 11 7 1 5 ] ;index2 = [0 128 64 192 32 160 96 224 16 144 80 208 48 176 112 2 4 0 ] ;out = zeros (1 ,256) ;k=0;for i =0:15

for j =0:15k = k + 1 ;out ( index2 ( j +1)+index1 ( i +1)+1) = in (k ) ;

endendend

MATLAB code om de 256 punts FFT te berekenen: p256_fft.m

function [ out ] = p25 6 f f t ( dat )

% func t i on to c a l c u l a t e a 256 po in t s f f t wi th the radix −2/4/8 a l gor i tm

% Fi r s t b u t t e r f l yt1 = p256 rad ix 4 ( dat ) ;

% Second b u t t e r f l yt21 = p64 rad i x 2 4 8 ( t1 ( 1 : 6 4 ) ) ;t22 = p64 rad i x 2 4 8 ( t1 ( 65 : 128 ) ) ;t23 = p64 rad i x 2 4 8 ( t1 (129 : 192 ) ) ;t24 = p64 rad i x 2 4 8 ( t1 (193 : 256 ) ) ;


% Third b u t t e r f l yt301 = p8 rad i x 2 4 8 ( t21 ( 1 : 8 ) ) ;t302 = p8 rad i x 2 4 8 ( t21 ( 9 : 1 6 ) ) ;t303 = p8 rad i x 2 4 8 ( t21 ( 17 : 2 4 ) ) ;t304 = p8 rad i x 2 4 8 ( t21 ( 25 : 3 2 ) ) ;t305 = p8 rad i x 2 4 8 ( t21 ( 33 : 4 0 ) ) ;t306 = p8 rad i x 2 4 8 ( t21 ( 41 : 4 8 ) ) ;t307 = p8 rad i x 2 4 8 ( t21 ( 49 : 5 6 ) ) ;t308 = p8 rad i x 2 4 8 ( t21 ( 57 : 6 4 ) ) ;t309 = p8 rad i x 2 4 8 ( t22 ( 1 : 8 ) ) ;t310 = p8 rad i x 2 4 8 ( t22 ( 9 : 1 6 ) ) ;t311 = p8 rad i x 2 4 8 ( t22 ( 17 : 2 4 ) ) ;t312 = p8 rad i x 2 4 8 ( t22 ( 25 : 3 2 ) ) ;t313 = p8 rad i x 2 4 8 ( t22 ( 33 : 4 0 ) ) ;t314 = p8 rad i x 2 4 8 ( t22 ( 41 : 4 8 ) ) ;t315 = p8 rad i x 2 4 8 ( t22 ( 49 : 5 6 ) ) ;t316 = p8 rad i x 2 4 8 ( t22 ( 57 : 6 4 ) ) ;t317 = p8 rad i x 2 4 8 ( t23 ( 1 : 8 ) ) ;t318 = p8 rad i x 2 4 8 ( t23 ( 9 : 1 6 ) ) ;t319 = p8 rad i x 2 4 8 ( t23 ( 17 : 2 4 ) ) ;t320 = p8 rad i x 2 4 8 ( t23 ( 25 : 3 2 ) ) ;t321 = p8 rad i x 2 4 8 ( t23 ( 33 : 4 0 ) ) ;t322 = p8 rad i x 2 4 8 ( t23 ( 41 : 4 8 ) ) ;t323 = p8 rad i x 2 4 8 ( t23 ( 49 : 5 6 ) ) ;t324 = p8 rad i x 2 4 8 ( t23 ( 57 : 6 4 ) ) ;t325 = p8 rad i x 2 4 8 ( t24 ( 1 : 8 ) ) ;t326 = p8 rad i x 2 4 8 ( t24 ( 9 : 1 6 ) ) ;t327 = p8 rad i x 2 4 8 ( t24 ( 17 : 2 4 ) ) ;t328 = p8 rad i x 2 4 8 ( t24 ( 25 : 3 2 ) ) ;t329 = p8 rad i x 2 4 8 ( t24 ( 33 : 4 0 ) ) ;t330 = p8 rad i x 2 4 8 ( t24 ( 41 : 4 8 ) ) ;t331 = p8 rad i x 2 4 8 ( t24 ( 49 : 5 6 ) ) ;t332 = p8 rad i x 2 4 8 ( t24 ( 57 : 6 4 ) ) ;

% Concatenate ou tpu t s t h i r d b u t t e r f l yY1 = [ t301 t302 t303 t304 t305 t306 t307 t308 t309 t310 t311 t312 t313 t314

t315 t316 . . .t317 t318 t319 t320 t321 t322 t323 t324 t325 t326 t327 t328 t329 t330

t331 t332 ] ;

out = arrange output (Y1) ;

MATLAB code van de testbench voor de 256 punts FFT: p256_fft_tb

A.2 C code voor de microcontroller INHOUDSOPGAVE

% Testbench s c r i p t f o r the 256 po in t s f f t

close a l l ;

SNR256 = zeros (1 ,100) ;

for i =1:100% Generation o f a random complex inputsequence 256 po in t s f f t ( input

range = [−2048 . . 2048])dat = 4096.*rand (1 ,256) − 2048 + j * (4096 .* rand (1 ,256) − 2048) ;

% Ca lcu l a t i on o f f f t wi th Matlab func t i on f o r r e f e r ence purposesY = f f t ( double ( dat ) ,256) ;

% Ca lcu l a t e 128 po in t s f f t wi th radix −2/4/8 a l gor i thmout = p25 6 f f t ( dat ) ;

% Check r e s u l t se r r s = out − Y;s i g = sum(abs (Y) . ˆ 2 ) /256 ;no i s e = sum(abs ( e r r s ) . ˆ 2 ) /256 ;SNR256( i ) = 10* log10 ( s i g / no i s e ) ;

end

figure ;plot (SNR256) ;

A.2 C code voor de microcontroller

C code voor de SPI interface: spi.c

//************************************************//// Handles the s p i i n t e r f a c e and se tup //// //// By Pepi jn Mist iaen ( lanquarden@gmail . com) ////

//// Fo l lowing p ins are used by the s p i i n t e r f a c e : //// P3 .1 (29) SIMO to SDI //// P3 .2 (30) SOMI to SDO //


// P3 .3 (31) UCLK to SPC //// P3 .4 (32) CS to CS ////************************************************//

#include #include #include #include ” l i s 3 0 2 d l . h”

signed char s p i r e ad (char addr ) {signed char data ;P3OUT &= ˜BIT4 ; // Enable s l a v eIFG1 &= ˜URXIFG0; // Clear f l a gTXBUF0 = LIS302DL READ + addr ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = 0 ; // Dummy wr i t e so we can read datawhile ( ! ( IFG1&URXIFG0) ) ; // Wait f o r RX to f i n i s hdata = RXBUF0;P3OUT |= BIT4 ; // Disab l e s l a v ereturn data ;

}

void s p i w r i t e (char addr , char va l ) {P3OUT &= ˜BIT4 ; // Enable s l a v eIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = LIS302DL WRITE + addr ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hIFG1 &= ˜URXIFG0; // Clear f l a g from f i r s t dummy by t eTXBUF0 = val ;while ( ! ( IFG1&URXIFG0) ) ; // Wait f o r TX to f i n i s hP3OUT |= BIT4 ; // Disab l e s l a v e

}

void s p i s e t up (void ) {P3SEL |= BIT1 + BIT2 + BIT3 ; // Setup P3 fo r SPI modeP3OUT |= BIT4 ; // Setup P3 .4 f o r enab l ing s l a v eP3DIR |= BIT4 + BIT3 + BIT1 ; // P3 .1 ,3 ,4 i s outputU0CTL |= CHAR + SYNC + MM; // 8− b i t Master SPI modeU0TCTL = CKPL + SSEL SMCLK + STC; // Po lar i t y , SMCLK, 3−wireU0BR0 = BIT1 ; // SPICLK=SMCLK/2U0BR1 = 0x00 ;U0MCTL = 0x00 ;


ME1 |= USPIE0 ; // SPI module enab ledUCTL0 &= ˜SWRST; // I n i t i a l i z e SPI s t a t e machine

}

Header file voor de SPI interface: spi.h

#ifndef SPI H#define SPI H

signed char s p i r e ad (char addr ) ;

void s p i w r i t e (char addr , char va l ) ;

void s p i s e t up (void ) ;

#endif

C code voor de seriële interface: uart.c

//************************************************//// Handles the uar t i n t e r f a c e and se tup //// //// By Pepi jn Mist iaen ( lanquarden@gmail . com) ////

//// Fo l lowing p ins are used by the uar t i n t e r f a c e : //// P3 .6 (34) TxD to RxD //// P3 .7 (35) RxD to TxD ////************************************************//

#include #include #include

void ua r t wr i t e (char va l ) {while ( ! ( IFG2 & UTXIFG1) ) ; // USART1 TX bu f f e r ready?TXBUF1 = val ; // va l to TXBUF1

}

void u a r t w r i t e i n t ( int va l ) {char l ow va l ;char h i gh va l ;l ow va l = va l & 0xFF ;h i gh va l = ( va l >> 8) & 0xFF ;ua r t wr i t e ( h i gh va l ) ;


ua r t wr i t e ( l ow va l ) ;}

void uar t s e tup (void ) {P3SEL |= 0xC0 ; // P3 .6 ,7 = USART1 TXD/RXDME2 |= UTXE1 + URXE1; // Enable USART1 TXD/RXDUCTL1 |= CHAR; // 8− b i t charac t e rUTCTL1 |= SSEL0 ; // UCLK = ACLKUBR01 = 0x03 ; // 32k/9600 − 3.41UBR11 = 0x00 ; //UMCTL1 = 0x4A ; // ModulationUCTL1 &= ˜SWRST; // I n i t i a l i z e USART s t a t e machine

}

Header file voor de seriële interface: uart.h

#ifndef UART H#define UART H

void ua r t wr i t e (char va l ) ;

void u a r t w r i t e i n t (

Ontwerp van een ademhalingssensor op basis van een...

Documents

Transcript of Ontwerp van een ademhalingssensor op basis van een...