Energy Harvesting Systems

Tom J. Ka´ mierski · Steve Beeby z
Editors

Energy Harvesting Systems
Principles, Modeling and Applications

123

Editors Tom J. Ka´ mierski z School of Electronics and Computer Science University of Southampton Southampton, SO17 1BJ, UK tjk@ecs.soton.ac.uk

Steve Beeby School of Electronics and Computer Science University of Southampton Southampton, SO17 1BJ, UK spb@ecs.soton.ac.uk

ISBN 978-1-4419-7565-2 e-ISBN 978-1-4419-7566-9 DOI 10.1007/978-1-4419-7566-9 Springer New York Dordrecht Heidelberg London
Library of Congress Control Number: 2010938327 c Springer Science+Business Media, LLC 2011 All rights reserved. This work may not be translated or copied in whole or in part without the written permission of the publisher (Springer Science+Business Media, LLC, 233 Spring Street, New York, NY 10013, USA), except for brief excerpts in connection with reviews or scholarly analysis. Use in connection with any form of information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed is forbidden. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. Printed on acid-free paper Springer is part of Springer Science+Business Media (www.springer.com)

Preface

Energy harvesting is the conversion of ambient energy present in the environment into electrical energy. It is identical in principle to large-scale renewable energy generation, for example, solar or wind power, but very different in scale. While large-scale power generation is concerned with megawatts of power, energy harvesting typically refers to micro- to milli-watts, i.e. much smaller power generation systems. The development of energy harvesting has been driven by the proliferation of autonomous wireless electronic systems. A classic example of such systems are wireless sensor nodes which combine together to form wireless sensor networks. Each sensor node typically comprises a sensor, processing electronics, wireless communications, and power supply. Since the system is by definition wireless and cannot be plugged into a mains supply, power has to be provided locally. Typically such a local power supply is provided a battery which on the face of it is convenient and low cost. However, batteries contain a finite supply of energy and require periodic replacement or recharging. This may be fine in individual deployments but across a wireless network containing a multitude of nodes batteries are clearly not attractive. Furthermore, the need to replace batteries means the wireless system has to be accessible which may not be possible or may compromise performance. Finally, there are environmental concerns about disposing of batteries. Energy harvesting was developed, therefore, as a method for replacing or augmenting batteries. By converting ambient energy in the environment, the energy harvester can provide the required electrical power for the lifetime of the wireless system which is also free to be embedded or placed wherever it is best suited to perform its function. Energy harvesting typically exploit kinetic, thermal, solar sources, or electromagnetic radiation sources. Kinetic energy harvesting converts movement, often in the form of vibrations, into electrical energy. Thermal gradients can be exploited by using thermoelectric generators while solar energy is harvested using photovoltaics. Electromagnetic radiation can capture the energy from radio waves but unless this energy is specifically broadcast, power levels are typically very low. The challenges for energy harvesting are to maximise the available electrical power from the ambient energy found in the application environment. Vibration energy harvesters, for example, need to be tuned to match characteristic frequencies found in the environment which often means bespoke generator designs are required for different applications. It would be much better if such generators v vi

Preface

were adaptable and able to cope with a range of frequencies. The energy conversion process does not stop with the generator; typically power conditioning electronics are also required to provide the electrical power in form acceptable to the system electronics. The design of the conditioning electronics often has an impact on the performance of the generator and therefore energy harvesting systems should be designed in a holistic manner considering all the essential blocks as a whole. This book addresses these challenges and describes the approaches that can be taken to overcome them. The first chapter provides a comprehensive introduction to operating principles of kinetic micro-generators and associated electronics with emphasis on adaptive kinetic energy harvesting. Kinetic energy harvesters, also known as vibration power generators, are typically, although not exclusively, inertial springmass systems where electrical power is extracted by employing one or a combination of different transduction mechanisms. As most vibration power generators are resonant systems, they generate maximum power when the resonant frequency of the generator matches the ambient vibration frequency. Adaptive generators try to minimise the difference between these two frequencies in order to maximise the amount of generated power. The chapter outlines extensively recent developments in adaptive kinetic energy harvesting and presents achievable improvements in the operating frequency range of such generators. The second chapter is devoted to design automation aspects of energy harvester systems. It presents an automated energy harvester design flow which is based on a single HDL software platform that can be used to model, simulate, configure and optimise a complete mixed physical-domain energy harvester system which includes the micro-generator, voltage booster, storage element and load. State-of-the art accurate hardware description language (HDL) modelling techniques for kinetic energy harvesters and their experimental validation are presented and discussed. Measurements have validated both the accuracy of HDL-based modelling and the efficiency of the automated design flow which can improve the amount of harvested energy in a typical system by 75%. The third chapter focuses on the power analysis and power harvesting in wireless sensor networks. Specifically, it gives an overview of power analysis simulation techniques and presents related tools and methodologies. The chapter also describes extension libraries for power analysis and models of energy harvester-based wireless sensors in SystemC and SystemC AMS complete with examples and simulation results. The final chapter presents a major industrial application of energy harvesting: the tyre pressure monitoring system (TPMS) recently developed at Infineon Technologies. Existing TPMS designs, which are based on batteries, suffer from difficulties in the energy budget management. The main challenge is to ensure a reliable RF data link from the sensor in the tyre to the receiver in the car due to the low energy available. Problems are aggravated when the car is used in extreme weather conditions, especially in winter, as batteries frequently fail in low temperatures. The chapter presents the advantages of Infineons revolutionary design which is based on an electrostatic vibration harvester. The design is highly miniaturised, with a volume less than 1 cm3 including the power supply and is embedded in the tyre. Results obtained from this case study provide a significant step towards intelligent tyres, which would be able to measure and report additional technical parameters

Preface

vii

for further enhancement of road safety. We hope that the reader of this book will gain a valuable insight into the state-of-the-art design techniques for autonomous wireless sensors powered by kinetic energy harvesters. The potential for electronic systems using various forms of “free energy”, such as kinetic, thermal, solar, RF and others, will continue to inspire researchers and engineers. In near future we will no doubt see new energy harvester designs, use of new materials, as well as innovative power management circuits and new solutions to energy storage. Energy harvester applications will benefit from further evolution in decreasing energy consumption due to novel circuit designs and the scaling down of nano-devices. New wireless communication techniques will also contribute to the reduction of energy consumption.

Southampton, UK

Tom J. Ka´ mierski z Steve Beeby

Contents

1 Kinetic Energy Harvesting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dibin Zhu and Steve Beeby

1

2 Modelling, Performance Optimisation and Automated Design of Mixed-Technology Energy Harvester Systems . . . . . . . . . . . . . . . . . . . . 79 Tom J. Ka´ mierski and Leran Wang z 3 Simulation of Ultra-Low Power Sensor Networks . . . . . . . . . . . . . . . . . . . 103 Jan Haase, Joseph Wenninger, Christoph Grimm, and Jiong Ou 4 Remote Sensing of Car Tire Pressure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Thomas Herndl Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

ix

Contributors

Steve Beeby School of Electronics and Computer Science, University of Southampton, Southampton UK, spb@ecs.soton.ac.uk Christoph Grimm Institute of Computer Technology, 1040 Vienna, Austria, grimm@ict.tuwien.ac.at Jan Haase Vienna University of Technology, Institute of Computer Technology, Gusshausstrasse 27-29, 1040 Vienna, Austria, haase@ict.tuwien.ac.at Thomas Herndl Infineon Technologies Austria AG, Vienna, Austria, thomas.herndl@infineon.com Tom J. Ka´ mierski School of Electronics and Computer Science, University of z Southampton, Southampton, UK, tjk@ecs.soton.ac.uk Jiong Ou Institute of Computer Technology, 1040 Vienna, Austria, ou@ict.tuwien.ac.at Leran Wang School of Electronics and Computer Science, University of Southampton, Southampton, UK, lw04r@ecs.soton.ac.uk Joseph Wenninger Institute of Computer Technology, 1040 Vienna, Austria wenninger@ict.tuwien.ac.at Dibin Zhu School of Electronics and Computer Science, University of Southampton, Southampton, UK, dz@ecs.soton.ac.uk

xi

Chapter 1

Kinetic Energy Harvesting
Dibin Zhu and Steve Beeby

Abstract This chapter introduces principles of normal kinetic energy harvesting and adaptive kinetic energy harvesting. Kinetic energy harvesters, also known as vibration power generators, are typically, although not exclusively, inertial springmass systems. Electrical power is extracted by employing one or a combination of different transduction mechanisms. Main transduction mechanisms are piezoelectric, electromagnetic and electrostatic. As most vibration power generators are resonant systems, they generate maximum power when the resonant frequency of the generator matches ambient vibration frequency. Any difference between these two frequencies can result in a significant decrease in generated power. Recent development in adaptive kinetic energy harvesting increases the operating frequency range of such generators. Possible solutions include tuning resonant frequency of the generator and widening the bandwidth of the generator. In this chapter, principles and operating strategies for adaptive kinetic energy harvesters will be presented and compared. Keywords Adaptive energy harvesting · Frequency tuning · Wider frequency range · Vibration energy harvesting

1.1 Introduction
Mechanical energy can be found almost anywhere that wireless sensor networks (WSN) may potentially be deployed, which makes converting mechanical energy from ambient vibration into electrical energy an attractive approach for powering wireless sensors. The source of mechanical energy can be a moving human body or a vibrating structure. The frequency of the mechanical excitation depends on the source: less than 10 Hz for human movements and over 30 Hz for machinery

D. Zhu (B) School of Electronics and Computer Science, University of Southampton, Southampton, UK e-mail: dz@ecs.soton.ac.uk

T.J. Ka´ mierski, S. Beeby (eds.), Energy Harvesting Systems, z DOI 10.1007/978-1-4419-7566-9_1, C Springer Science+Business Media, LLC 2011

1

2

D. Zhu and S. Beeby

vibrations [1]. Such devices are known as kinetic energy harvesters or vibration power generators [2]. In practical machine-based applications, vibration levels can be very low ( c t r l ( o u t ) ; } };

be changed during the simulation, is detected and set up correctly during the elaboration phase, which is a step between setting up the whole system and connecting all signals and the actual start of the simulation. Fig. 3.12 shows a simple cluster consisting of four functional nodes and a delay element. As can be seen, the module ipl generates two tokens at each given invocation and the node dec consumes always two data values at each invocation. In between is the node calculating the function f1, which consumes and produces one value at each invocation; therefore, within one cluster period the processing function of f1 is invoked twice. dec itself just produces one token and f2 consumes one token, so f2 is only evaluated once per cluster period. Since the given example contains a loop there has to be a dead time or delay element to break the direct loop, otherwise the simulation could not progress, since the cycle would be evaluated endlessly during one simulation step. If there would not be a loop, there would not be the need for a delay element per se, although it might arise the need, depending on which physical behaviour is going to be modelled and how accurately it is modelled, e.g. settling times could be simulated with delays. An example TDF module can be seen in Table 3.2. In this example we highlight what is the important stuff and split the module up according to the functionality of the source line to give a better overview of the semantics.

116
:= set of connected TDF modules

J. Haase et al.

rate=2

rate=2 order of computation

ipl

f1

dec

delay

f2

ipl f1 f1 dec f2 delay

cluster period

delay=1

T=1 t0=0

Fig. 3.12 Example cluster (left) with its execution schedule (right) due to the different number of tokens produced, respectively consumed Table 3.2 Implementation of a parallel to serial converter with TDF. The different section of the module are separated and described Module function Sample code TDF module: primitive module
SCA_TDF_MODULE(par2ser) { sca_tdf::sca_in in; sca_tdf::sca_out out; void set_attributes() { out.set_rate(8); out.set_delay(1); out.set_timestep(1, SC_MS); } void processing() { for (int i=7; i >= 0 ; i– ) out.write(in.get_bit(i), i); } SCA_CTOR(par2ser); }

Attributes specify timed semantics

Processing() describes computation

Standard constructor

3.2.6 Network Level Simulation
In Section 3.2.4 and Section 3.2.5 it has been described how to describe and simulate parts, for instance, the nodes of the system in greater details. However, there is the need to simulate the overall network, not only the subsystems, to get a better feeling of the overall power consumption of the complete system, which a node is only a part of. Although work is done at the Vienna University of Technology to simulate the whole network level also with SystemC and SystemC AMS this is not yet ready for prime time, but there are state-of-the-art tools which could be used for the network level and it is even possible to let those tools cooperate with SystemC

3 Simulation of Ultra-Low Power Sensor Networks

117

to simulate nodes at a fine-grained level and the network in an overview-like level. One of these tools is the OMNET++ network simulator [8]. It is a C-based tool based on a discrete event (DE) kernel. It is free for academy and educational use, but a license has to be payed for commercial usage. It contains a graphical network editor and describes networks with an own network topology description language, the NED. It is a very well-suited tool for simulation of sensor networks and allows co-simulation with SystemC. A screenshot of this tool can be seen in Fig. 3.13.

Fig. 3.13 OMNeT++ GUI

3.3 Modeling Strategies for Power Simulation
In Section 3.1 and Section 3.2 the basic problems, goals and possible tools have been described. Now it is time to go further into details on how to do the modelling. It would be ideal for all models if the power consumption would follow a linear function depending on the components or functions being used. If an ADC is turned on the power consumption always increases the same way and if it is turned off, it decreases always in the same way. The real world is not ideal though, so there is an additional component to the power consumption, which is nasty for modelling purposes. This consumption is dependent on dynamic behaviour and on the history of state changes in the previous (one or more) cycles. So each state/function/component is not characterized by a factor, but by a time-dependent function. Fig. 3.14 shows a visualization. In this figure “State A” could be described as time

118

J. Haase et al.

Fig. 3.14 Dynamic behaviour = time-dependent power consumption within states

Fig. 3.15 Power equation: the total power consumption Itot is the sum of the static, dynamic and leakage power

independent in the zeroth order, whereas “State B” is very type dependent. The complete power consumption, i.e. the current the power supply has to deliver to a system, can be calculated as Itotal = Istat + Idynamic + Ileak . This equation is shown graphically in Fig. 3.15.

3.3.1 Power Analysis
Power analysis is the method of estimating or measuring power usage of a system and drawing conclusion out of the data. The method of doing a power analysis can be described as a cycle, which has some iterations, until the optimization goal has been reached or the decision has to be made, that it is not possible with the given technologies and constraints. As it can be seen in Fig. 3.16 the designer starts with creating a model for the whole system, considering all external constraints. After that the simulation is run in respect of important corner cases, which have to be defined beforehand. During the simulation all usage of each functional block is monitored and somehow logged so this statistical data can be interpreted later on. As a next step the data are used to calculate the overall power consumption, based on multiplication factors or at least linear functions of power consumption per component/function. If the power consumption is not within the allowed range the various parameters (technology, architecture, etc.) have to modified and the whole simulation has to be rerun. It is usually the case that more than one iteration is needed to achieve good results. Since the analysis needs a lot of runs and the simulation has to cover large time spans to give good results, the performance of the simulation model is essential to keep time frames and schedules. To keep the simulation feasible even for

3 Simulation of Ultra-Low Power Sensor Networks

119

Fig. 3.16 Cycle of analysis

very complex heterogeneous systems consisting of hardware, software and analog mixed signal parts while doing very long time observations the need arises to do concessions: 1. Create models as abstract as possible (but not more abstract than that, otherwise the results are meaningless) 2. Document and communicate which properties and constraints are modelled, which are not and why 3. Be very careful about which information you are tracing and how you are tracing them. Without care traces may become as large as many terabytes, which is not handy for further interpretation tasks. It is good practice to separate nodes into functional blocks, which can be used independently of each other. This increases the possibility of reuse and has the advantage that various parts can be simulated with different levels of detail. A possible structural dissection would be • • • • • ADC Sensor interface Transmitter Receiver Software function calls

For the actual analysis it is a good idea to add a dedicated power meter interface to the simulation (environment), which receives messages from all functional blocks about their current power consumption. To optimize the trace sizes consider trace changes of the consumption and not the consumption itself. This leads to fewer data points and increases the speed of the overall simulation and analysis. The final reports can be of different form, e.g. comma separated value (CSV) files or images showing curves.

120

J. Haase et al.

3.3.2 Example: State Machine
If a state machine is simulated, in most cases only the functionality is modelled and simulated. For instance, if it has n discrete states si , within each state the function fi is implemented as C or C++ code which takes the input signals and the simulation time as parameters and then computes the state changes and the output vector. In this example of the power simulation a power reporter pi has to be attached to each state si . This reporter is program code which calculates or estimates the power consumption of the functional task and reports it to the overall power meter in the form of P = U 2 /R + const. In this case U is the supply voltage, R is an equivalent resistor and const is just a model-specific constant value. The report can be more complex though, for instance, for any kind of (non)linear function. The state machine described here is called state machine with function and power reporting (SMFP). Creating a power estimation of software functions can also be done with this SMFP model. This is done by creating a timed functional model of the software on the CPU (central processing unit). The estimated runtime (ti ) of each function or procedure f i is retrieved by measurement or by counting the assembler instructions and adding up the times needed for each instruction. As a next step the software’s use of the microcontroller is mapped to the SMFP model. The power of each function can either be measured or be calculated from data sheets, usually the power consumption pi is nearly constant within each state. The SMFP model reports power usage pi for execution times ti of function f i . In all other cases the SMFP model reports a power consumption psleep to the power metre monitor. Even complex functional hardware blocks can be mapped to the SMFP model. For instance, analog digital converters (ADCs), phase-locked loops (PLLs), transmitters or receivers are such modules, which could be bisected and modelled in greater detail or can be modelled as just a functional block with an SMFP. The SMFP template is characterized through circuit simulation, measurements and data sheets to adapt it to the given component.

3.3.3 Modelling the Channel (Air)
In a communication system the transmission channel is of crucial importance. In wireless communication environments this channel usually has the abstract name “the Air”. The channel is characterized by reflections, refractions, scattering, fading and in general attenuation of the transmitted signal. In addition the media access scheme is also important; common schemes are TDMA (time division multiple access), FDMA (frequency division multiple access) and CDMA (code division multiple access). From these parameters a matrix can be built, which contains the elements Ai, j = PRx,i /PTx, j , which describe the attenuation between any given transmitter Tx,i and receiver R x,i .

3 Simulation of Ultra-Low Power Sensor Networks

121

3.4 TUV Building Block Library
The Vienna University of Technology (TUV) building block library is a set of SystemC AMS classes for high-level simulation of analog mixed signal modules. It has been published publicly for the first time in conjunction with the ANDRES framework [3], which has been funded by the European Union. It consists of signal sources, signal processing and signal analysis modules. All those modules are based on SystemC AMS. It is published free for private and academic use and can be freely downloaded from [1]. In this section, only a selection of modules and covered areas is shown, as the complete list would fill pages and pages: • Signal sources – Gaussian distributed random numbers – Uniformly distributed random numbers – Sine – Saw tooth wave – etc. • Signal processing – Mathematical functions – Nonlinearities – Basic RF blocks – (De)Modulators – etc. • Signal analysis – Eye diagram – Scatter plot – Network analyzer

3.4.1 Introduction to Example Implementation of a Transceiver System
In the following sections (Section 3.4.3, Section 3.4.4, Section 3.4.5, Section 3.4.6) an implementation of an orthogonal frequency division multiplexing (OFDM) transceiver is shown as an example to demonstrate the usefulness of the building block library. It is first implemented as “old style” and then using the library. The system to be built and simulated is depicted in Fig. 3.17. It consists of a generator of test patterns, which are going to be transmitted over the channel with the OFDM

Fig. 3.17 Example transceiver block schematic

122

J. Haase et al.

modulation. These patterns are handed over to the transmitter module, which does the whole of coding and modulating and handing it over to the channel, which in our case will be a simulation of a transmission through the air with attenuation and noise. This modified signal is afterwards handed over to the transceiver which does the demodulation and returns the bitstream of the received test patterns.

3.4.2 Why Simulate Analog Components
In the context of sensor networks and particularly in low-power sensor networks, transceiver systems are important. The classic sensor networks used wires to connect the various components. This had and still has the advantage that there is a clear line of communication, the wire. Clear bus semantics can be applied to the system, concerning the bus arbitration and electro-magnetic compatibility (EMC). Another advantage of wired buses is that it is easy to estimate the energy consumption of the sending and receiving parts quite easily, because it depends mostly on the system geometry and the resistance of the wires. The big drawback is that the wires have to be placed into building or vehicle structures or for overland networks into the earth or on pylons. With wires on pylons there is the increased danger of lightning strokes, which have to be reduced again through additional lightning protection measures. Contemporary sensor networks often turn away from wired connections to wireless communication for various reasons. Only short antennas are needed instead of pylons for overland networks and even within objects (buildings, vehicles) there is a big advantage, as no cable connections have to be created between the various nodes of the network. This allows the placement of sensors at points important for data acquisition, even if it would be very expensive or not possible at all to create a reliable wired connection because of the objects geometry or because of moving parts. So it can be said that wireless communication enhances the flexibility of the network. The disadvantage of a wireless sensor network lies in the fact that the power consumption cannot be that easily calculated, because the transmission and receiver unit have no direct point-to-point connections via a wire and therefore the energy is not merely independent of other factors than the geometry of the system. Very important is the influence from other transmission systems sharing the same frequency band (collisions) or having harmonics within the band of interest. Other factors are shielding through stationary, pseudo-stationary moving objects and reflections of signals. Those factors very often lead to retransmissions, more than in wired systems, or to adaption of the transmission power or receiver gain. The energy consumption is most of the time not a linear function. So the best thing to estimate the power consumption and to simulate the system’s functional behaviour is to also simulate the analog parts. A wireless sensor network can have either all nodes equal or some nodes with energy constraints and a base station, where energy does not have that big an influence. For instance, the base station is powered via the ordinary power grid, whereas the sensor nodes (agent nodes) are powered by battery or solar cells or other sources of energy, e.g. kinetic energy. In this case for a first estimate

3 Simulation of Ultra-Low Power Sensor Networks

123

you only need to model the agent node precisely, whereas the base station can be modelled roughly, just to simulate the functionality, without the energy simulation part. As we will see in Section 3.4.5 the library is especially useful for this part of the simulation, because it reduces the coding work and provides a consistent handling and good interconnectability of the modules. There is ongoing work done with the building block library to integrate power annotations and estimations to the modules to enable the user to even evaluate power consumption on a high level, to ease the design space exploration. Design space exploration is a very important part in sensor networks, since it helps finding the optimal solutions between analog hardware, digital hardware and software components and their parameters.

3.4.3 What Is OFDM?
OFDM stands for orthogonal frequency division multiplexing. It is a transmission technique often used in popular modern wireless communication systems; this is why it is used for the example here. The transmitter for OFDM, which is shown in Fig. 3.18, takes a serial stream of binary digits. By inverse multiplexing, these are first demultiplexed into N parallel streams, and each one mapped to a (possibly complex) symbol stream using QAM modulation. An inverse FFT is computed on each set of symbols, giving a set of complex time-domain samples. These samples are then quadrature mixed to passband in the standard way. Fig. 3.19 shows which parts compose an OFDM receiver. The receiver picks up the signal from an antenna, which is then quadrature mixed down to baseband using cosine and sine waves at the carrier frequency. This also creates signals centred on two times the carrier frequency 2 ∗ f c, so low-pass filters are used to reject these. The baseband signals are then sampled and a forward FFT is used to convert back to the frequency domain. This returns N parallel streams; each of which is converted to a binary stream using an appropriate symbol detector. These streams are then

Fig. 3.18 Block schematic of the example OFDM transmitter

124

J. Haase et al.

Fig. 3.19 Block schematic of the example OFDM receiver

re-combined into a serial stream, which is an estimate of the original binary stream at the transmitter.

3.4.4 Full-Fledged OFDM Transceiver System
In this section we are going to implement the OFDM transceiver completely without the usage of the building block library or better said, we will show the implementation of the building block modules needed for creating the OFDM transceiver. This chapter focuses on the amount of code needed, not on explaining the complete inner workings; the motto is going to be, let the code speak for itself. An impression of the work should be given, but to not explode the book, just the top-level modules and one four sub-modules of the lower level modules are shown. This is just to get a feeling how much code the implementation of an OFDM transceiver system is. Later on in Section 3.4.5 we are going to show how easy it is to implement the whole system by just using the library instead of reinventing the wheel.

3 Simulation of Ultra-Low Power Sensor Networks

125

Listing 3.2 OFDM transceiver(1)
1 2 3 4 5 6 7 8 9 10 11 12

/ * ******** OFDM_Transmitter ********** * / t e m p l a t e < i n t N> SC_MODULE( ofdm_se ) { public : / / Ports : s c a _ t d f : : s c a _ i n < bool > i n ; s c a _ t d f : : s c a _ o u t < double > o u t ;

/ / input port / / output port

13

14

15

16

17

18

// signals s c a _ t d f : : s c a _ s i g n a l < bool > s i g _ p a [N ] ; s2p o u t p u t p o r t s s c a _ t d f : : s c a _ s i g n a l < double > s i g _ r e a l [N ] ; q_mapper i o u t p u t p o r t s s c a _ t d f : : s c a _ s i g n a l < double > s i g _ i m a g [N ] ; q_mapper q o u t p u t p o r t s s c a _ t d f : : s c a _ s i g n a l < double > s i g _ o u t _ r e a l [N ] ; f f t real output ports s c a _ t d f : : s c a _ s i g n a l < double > s i g _ o u t _ i m a g [N ] ; f f t imag o u t p u t p o r t s s c a _ t d f : : s c a _ s i g n a l < double > s i g _ o u t _ i ; p2s i o u t p u t p o r t s s c a _ t d f : : s c a _ s i g n a l < double > s i g _ o u t _ q ; p2s q o u t p u t p o r t s private : / / module i n s t a n t i a t i o n s2p < bool , N> * s 2 p _ s u b ; qam_map * qam_mapper_sub [N ] ; f f t _ i f f t * i f f t _ s u b ; p2s < double , N> * p 2 s _ r _ s u b ; p2s < double , N> * p 2 s _ i _ s u b ; q_mixer_tr * q_mixer_tr_sub ;

/ / s i g n a l s on / / s i g n a l s on / / s i g n a l s on / / s i g n a l s on / / s i g n a l s on / / s i g n a l s on / / s i g n a l s on

19 20 21 22 23 24 25 26 27

126

J. Haase et al.

Listing 3.3 OFDM transceiver(2)
1 2 3

4 5 6

public : / / Constructor ofdm_se ( s c _ c o r e : : sc_module_name n , d o u b l e m i x e r _ f c , i n t qam_p_num , d o u b l e b i t _ f , i n t d o u t _ r a t e , d o u b l e _amp =1 , i n t s 2 p _ o r =1 , b o o l m i x e r _ c o n f i g = f a l s e , i n t p 2 s _ r a t e = 1 ) { i n t m i x e r _ r a t e = ( i n t ) f l o o r ( d o u t _ r a t e * l o g 2 ( qam_p_num ) * mixer_fc / b i t _ f ) ; s 2 p _ s u b = new s2p < bool , N> ( " s 2 p _ s u b " , 1 ) ; s 2 p _ s u b −> i n ( i n ) ; f o r ( i n t i = 0 ; i o u t [ i ] ( s i g _ p a [ i ] ) ; f o r ( i n t i = 0 ; i i n ( s i g _ p a [ i ] ) ; qam_mapper_sub [ i ]−> o u t _ i ( s i g _ r e a l [ i ] ) ; qam_mapper_sub [ i ]−> o u t _ q ( s i g _ i m a g [ i ] ) ; } i f f t _ s u b = new f f t _ i f f t ( " i f f t _ s u b " , " IFFT " ) ; f o r ( i n t i = 0 ; i i n _ r e a l [ i ] ( s i g _ r e a l [ i ] ) ; i f f t _ s u b −>i n _ i m a g [ i ] ( s i g _ i m a g [ i ] ) ; i f f t _ s u b −> o u t _ r e a l [ i ] ( s i g _ o u t _ r e a l [ i ] ) ; i f f t _ s u b −>o u t _ i m a g [ i ] ( s i g _ o u t _ i m a g [ i ] ) ; } p 2 s _ r _ s u b = new p2s < double , N> ( " p 2 s _ r _ s u b " , p 2 s _ r a t e ) ; f o r ( i n t i = 0 ; i i n [ i ] ( s i g _ o u t _ r e a l [ i ] ) ; } p 2 s _ r _ s u b −>o u t ( s i g _ o u t _ i ) ; p 2 s _ i _ s u b = new p2s < double , N> ( " p 2 s _ i _ s u b " , p 2 s _ r a t e ) ; f o r ( i n t i = 0 ; i i n [ i ] ( s i g _ o u t _ i m a g [ i ] ) ; } p 2 s _ i _ s u b −>o u t ( s i g _ o u t _ q ) ; q _ m i x e r _ t r _ s u b = new q _ m i x e r _ t r ( " q _ m i x e r _ t r _ s u b " , m i x e r _ f c , _amp , m i x e r _ r a t e , m i x e r _ c o n f i g , 0 . , 0 . ) ; q _ m i x e r _ t r _ s u b −> i _ i n ( s i g _ o u t _ i ) ; q _ m i x e r _ t r _ s u b −>q _ i n ( s i g _ o u t _ q ) ; q _ m i x e r _ t r _ s u b −>o u t ( o u t ) ; } };

7 8 9 10 11 12 13 14

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

45 46 47 48 49 50

3 Simulation of Ultra-Low Power Sensor Networks

127

Listing 3.4 OFDM receiver(1)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

/ * ******** OFDM_Receiver ********** * / t e m p l a t e < i n t N> SC_MODULE( o f d m _ r e ) { public : / / Ports s c a _ t d f : : s c a _ i n < double > i n ; s c a _ t d f : : s c a _ o u t < bool > o u t ;

/ / input port / / output port

/ / Signals s c a _ t d f : : s c a _ s i g n a l < double > s i g _ i n _ i ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ i n _ q ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ i _ l p ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ q _ l p ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ i _ r o u n d e d ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ q _ r o u n d e d ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ r e _ r e a l [N ] ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ r e _ i m a g [N ] ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ r e _ o u t _ r e a l [N ] ; s c a _ t d f : : s c a _ s i g n a l < double > s i g _ r e _ o u t _ i m a g [N ] ; s c a _ t d f : : s c a _ s i g n a l < bool > s i g _ d e m a p p e r [N ] ; s c a _ t d f : : s c a _ s i g n a l < bool > s i g _ r e c e i v e d ; private : / / module i n s t a n t i a t i o n q_mixer_re * q_mixer_re_sub ; lp * i_lp ; lp * q_lp ; downsample * i _ r o u n d ; downsample * q _ r o u n d ; s2p < double , N> * s 2 p _ r _ s u b ; s2p < double , N> * s 2 p _ i _ s u b ; f f t _ i f f t * f f t _ s u b ; qam_demap * qam_demapper_sub [N ] ; p2s < bool , N> * p 2 s _ s u b ;

128

J. Haase et al.

Listing 3.5 OFDM receiver(2)
1 2 3

4 5 6

public : / / Constructor o f d m _ r e ( s c _ c o r e : : sc_module_name n , d o u b l e m i x e r _ f c , i n t demap_p , d o u b l e b i t _ f , i n t d o u t _ r a t e , d o u b l e _amp =1 , i n t p 2 s _ r a t e =1) { i n t m i x e r _ r a t e = ( i n t ) f l o o r ( d o u t _ r a t e * l o g 2 ( demap_p ) * mixer_fc / b i t _ f ) ; q _ m i x e r _ r e _ s u b = new q _ m i x e r _ r e ( " m i x e r _ s u b " , m i x e r _ f c , _amp , m i x e r _ r a t e , f a l s e , 0 . , 0 . ) ; q _ m i x e r _ r e _ s u b −> i n ( i n ) ; q _ m i x e r _ r e _ s u b −> i _ o u t ( s i g _ i n _ i ) ; q _ m i x e r _ r e _ s u b −>q _ o u t ( s i g _ i n _ q ) ; i _ l p = new l p ( " i _ l p " , m i x e r _ f c / 1 0 0 0 . 0 ) ; i _ l p −> i n ( s i g _ i n _ i ) ; i _ l p −>o u t ( s i g _ i _ l p ) ; q _ l p = new l p ( " q _ l p " , m i x e r _ f c / 1 0 0 0 . 0 ) ; q _ l p −> i n ( s i g _ i n _ q ) ; q _ l p −>o u t ( s i g _ q _ l p ) ; i _ r o u n d = new downsample ( " i _ r o u n d " , m i x e r _ r a t e , mixer_rate ) ; i _ r o u n d −> i n ( s i g _ i _ l p ) ; i _ r o u n d −>o u t ( s i g _ i _ r o u n d e d ) ; q _ r o u n d = new downsample ( " q _ r o u n d " , m i x e r _ r a t e , mixer_rate ) ; q_round −> i n ( s i g _ q _ l p ) ; q_round −>o u t ( s i g _ q _ r o u n d e d ) ; s 2 p _ r _ s u b = new s2p < double , N> ( " s 2 p _ r _ s u b " , 1 ) ; s 2 p _ r _ s u b −> i n ( s i g _ i _ r o u n d e d ) ; f o r ( i n t i = 0 ; i o u t [ i ] ( s i g _ r e _ r e a l [ i ] ) ; } s 2 p _ i _ s u b = new s2p < double , N> ( " s 2 p _ i _ s u b " , 1 ) ; s 2 p _ i _ s u b −> i n ( s i g _ q _ r o u n d e d ) ; f o r ( i n t i = 0 ; i o u t [ i ] ( s i g _ r e _ i m a g [ i ] ) ; }

7

8 9 10 11 12 13 14 15 16 17 18 19 20

21 22 23 24

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

3 Simulation of Ultra-Low Power Sensor Networks

129

Listing 3.6 OFDM receiver(3)
1 2 3 4 5 6 7 8 9 10 11 12

f f t _ s u b = new f f t _ i f f t ( " f f t _ s u b " , " FFT " ) ; f o r ( i n t i = 0 ; i i n _ r e a l [ i ] ( s i g _ r e _ r e a l [ i ] ) ; f f t _ s u b −>i n _ i m a g [ i ] ( s i g _ r e _ i m a g [ i ] ) ; f f t _ s u b −> o u t _ r e a l [ i ] ( s i g _ r e _ o u t _ r e a l [ i ] ) ; f f t _ s u b −>o u t _ i m a g [ i ] ( s i g _ r e _ o u t _ i m a g [ i ] ) ; } f o r ( i n t i = 0 ; i o u t ( s i g _ d e m a p p e r [ i ] ) ; qam_demapper_sub [ i ]−> i n _ i ( s i g _ r e _ o u t _ r e a l [ i ] ) ; qam_demapper_sub [ i ]−> i n _ q ( s i g _ r e _ o u t _ i m a g [ i ] ) ; } p 2 s _ s u b = new p2s < bool , N> ( " p 2 s _ s u b " , p 2 s _ r a t e ) ; f o r ( i n t i = 0 ; i i n [ i ] ( s i g _ d e m a p p e r [ i ] ) ; } p 2 s _ s u b −>o u t ( o u t ) ; } };

13 14 15 16 17 18 19 20 21 22 23 24 25 26

130

J. Haase et al.

Listing 3.7 Parallel to serial converter
1

/ * **************************************** p a r a l l e l t o s e r i a l c o n v e r t e r ********************************* * / t e m p l a t e < c l a s s T , i n t N> SCA_TDF_MODULE( p 2 s ) { s c a _ t d f : : s c a _ i n i n [N ] ; ports s c a _ t d f : : s c a _ o u t o u t ; port private : int in_rate ; int out_rate ; void s e t _ a t t r i b u t e s ( ) { f o r ( i n t i = 0 ; i SCA_TDF_MODULE( s 2 p ) { s c a _ t d f : : s c a _ i n i n ; s c a _ t d f : : s c a _ o u t o u t [N ] ; private : int out_rate ; int in_rate ; void i n i t i a l i z e ( ) {}; void s e t _ a t t r i b u t e s ( ) { f o r ( i n t i = 0 ; i i n _ r e a l [N ] ; s c a _ t d f : : s c a _ i n < double > i n _ i m a g [N ] ; s c a _ t d f : : s c a _ o u t < double > o u t _ r e a l [N ] ; s c a _ t d f : : s c a _ o u t < double > o u t _ i m a g [N ] ; private : s t r i n g mode ; int isign ; d o u b l e ZERO_THRESHOLD ; b o o l debug ; void s e t _ a t t r i b u t e s ( ) { } void i n i t i a l i z e ( ) { } void p r o c e s s i n g ( ) { v e c t o r < double > d a t a ; d o u b l e wtemp , wr , wpr , wpi , wi , t h e t a ; f l o a t tempr , t e m p i ; int istep ; debug = f a l s e ; f o r ( i n t j = 0 ; j =2 && j >m) { j −= m; m >>= 1 ; } j += m; } i f ( debug == t r u e ) { c o u t