EFSA steps up ASF control efforts in south-eastern Europe
EFSA has begun a major campaign to raise awareness and help halt the spread of African swine fever in south-east Europe.
The campaign is aimed at countries that in 2019 EFSA identified as collectively comprising a “region of concern” because of their proximity to countries where ASF is present. These are Albania, Bosnia and Herzegovina, Croatia, Greece, Kosovo, Montenegro, North Macedonia, Serbia and Slovenia.
The EFSA campaign will complement the ongoing efforts of the European Commission and other international organisations to work towards the eradication of the disease in Europe.
What is African swine fever?
African swine fever (ASF) is a viral disease that affects domestic pigs and wild boar. The virus is harmless to humans but has caused significant economic disruption in many countries. There are currently no vaccines for ASF, so an outbreak can necessitate the slaughter of large numbers of farm-kept pigs in affected areas.
Objectives and audiences
The campaign aims to raise awareness and understanding of ASF in all nine countries. It is aimed at groups of people and individuals who come into contact with domestic pigs and wild boar, such as pig farmers and hunters. EFSA will also engage with veterinary organisations, hunting associations, farmers’ groups, customs officers, border police, local governments, tourist operators, and travellers.
Detect, prevent, report
Because an ASF outbreak can have such devastating effects, detection, prevention and reporting are essential if this disease is to be contained. These are the key words of our campaign.


The planet is experiencing “a summer of swelter,” states a front-page story in today’s Globe and Mail that provides us with anecdotes of the upshot, such as “more than 1000 Russians have drowned in the last month trying to escape record temperatures.” The Globe then speculates that one cause of the worldwide heat wave could be “the ever-shrinking size of the world’s ice caps.”
First, the Russians. The Globe might have told us that they drown in droves every year, disproportionately in the summer months, and the Globe might also have told us why. “The majority of those drowned were drunk,” explains Vadim Seryogin, a department head at Russia’s Emergencies Ministry. Last year, when 3000 Russian drowned, one analysis of drowned Russian males found that 94% had been drunk.
Perhaps the heat caused Russians to drink more – the data is not yet in – but most don’t need heat to drive them to drink. According to a study last year published in the British journal, the Lancet, alcohol was responsible for the deaths of about three quarters of all Russian men, and half of all Russian women, aged 15-54.
Next, those “ever-shrinking” ice caps, of which this planet has two. The ice cap in the southern hemisphere, in the Antarctic, has been
, especially so
. The ice cap in the northern hemisphere, in contrast, did shrink temporarily over the last few months, after having expanded temporarily earlier in the year, and it is now expanding again. On balance, Planet Earth now has slightly more ice than usual, according to the most recent data from the National Oceanic and Atmospheric Administration. It shows the Arctic to have 1.379 million fewer million square kilometres of ice while the Antarctic has 1.404 more.
“Ice reflects sun and when you melt it, the Earth absorbs more heat, which causes further melt back, which causes more warming,” Danny Harvey, a climate researcher at University of Toronto, told The Globe. “So when you lose ice, it means we’re in big trouble.”
So, when we gain ice, as the Earth is now doing, does it mean we are we safe and sound? The Globe didn’t ask, and Harvey didn’t answer.
Lawrence Solomon is executive director of
and the author of


A Labor Day Weekend How-to-Help-Save-the Ocean Video
by Bill Chameides | August 30th, 2013
posted by Erica Rowell (Editor)
Ocean debris specialist Nick Mallos, a Nicholas School graduate, offers up 6 ways to stop plastic pollution. Watch video here.
For many Americans, Labor Day Weekend is traditionally the last one for a romp in oceans. Plastic should be on their minds.
Study after study shows that we have a real plastic problem in our oceans.
The Pacific Ocean garbage patch is a fairly well known. But I suspect most people’s image of it is not quite correct. While some news reports and websites have given the impression that it’s one big landfill (sic) swirling in the middle of the ocean (see here and here), truth is that it’s much more diffuse. Much of it is tiny fragments of plastic that have broken down into very small pieces but not completely. And while that might seem to be better than a big landfill, it’s not. Why? Because it’s tiny, it can’t just be scooped up or contained. Also it doesn’t ever completely degrade. Here’s how NOAA explains it:
“Plastics will degrade into small pieces until you can’t see them anymore (so small you’d need a microscope or better!). Because the ocean is a cold, dark place, this process happens slower in water than on land. But, do plastics fully “go away?” Full degradation into carbon dioxide, water, and inorganic molecules is called mineralization. Most commonly used plastics do not mineralize (or go away) in the ocean and instead break down into smaller and smaller pieces. We call these pieces “microplastics” if they are less than 5mm long.”
And these little fragments circulate for decades on decades, poisoning our environment and endangering the health of wildlife as well as, some studies show, human health.
In February, nine scientists wrote an appeal in the journal Nature to reclassify many of the plastics that fill our lives as hazardous.
They argued that “the chemical ingredients of more than 50% of plastics are hazardous. Studies investigating, for instance, the transfer of additives in polyvinylchloride (PVC) from medical supplies to humans indicate that these chemicals can accumulate in the blood. In laboratory tests, monomers and other ingredients of PVC, polystyrene, polyurethane and polycarbonate can be carcinogenic and can affect organisms in a similar way to the hormone oestrogen.”
What to Do
This is a problem that actually has a pretty straightforward solution, one that requires that we change how we do things, but there’s really not much sacrifice involved. We just need to use less plastic. Most egregious are single-use, throwaway plastics that have a lifespan of minutes. Stop using that stuff and we stanch a lot of the flow of plastic into our oceans.
As Nick Mallos, Nicholas School graduate and conservation biologist for Ocean Conservancy* puts it, “At its core ocean trash is not an ocean problem, it’s a people problem. That means we are the solution.”
Check out Nick’s six steps to a cleaner ocean.
So this Labor Day the watchword is “DEPLACTICIZE.”
Note: Nick wanted to let folks know that Ocean Conservancy is having its annual International Coastal Cleanup on September 21. (Sign up here.) It’s an event they’ve held since 1986, in which volunteers from around the globe head to nearby beaches to clean them up. In 2012, more than half a million people collected more than 10 million pounds of trash.filed under: faculty, oceans, pollution
and: consumer tips, consumers, plastic, tips


A Big Need for Common-Standards Curriculum Resources
Educators are yearning for instructional resources to help them turn the common standards into curriculum and instruction in their schools. That is no surprise, given the big change that the new standards require in teaching and learning. But the yearning came through loud and clear during a webinar we hosted last week on implementing the common standards. (If you missed the webinar, you can see it here.)
Of all the questions that came pouring in before and during the webinar, one of the most frequently asked was some variation on this: Where can I get sample lessons to help me teach the new standards?
The quick answer is that it's tough to find stuff that's been collected in central places for easy retrieval. Eventually, these sorts of resources will be available in digital libraries being built by the two federally funded assessment consortia. But those are still under construction.
I'd been hearing that some of the lead writers of the common standards had videotaped sample lessons, but even some of those who had worked on them couldn't tell me where I could find any more than a couple lessons. Eventually, I found a bunch on the website of the Council of Chief State School Officers' group that focuses on common-standards implementation. The link on its page takes you to a YouTube video collection of lessons in math and English/language arts, put together by the James B. Hunt Institute, which has worked to promote the common standards. And judging by the number of times these videos have been viewed, I'm not the only one who had a hard time finding them.
The New York state department of education has assembled a clearinghouse of resources for the common core, as well. One page on that site is devoted to curriculum exemplars, which include sample units in math and English/language arts. It also has a series of videos explaining key aspects of the common standards, including a sample lesson by David Coleman, one of the two lead writers of the English/language arts standards, on Lincoln's "Gettysburg Address." Presumably, more of these clearinghouses will crop up as states and districts develop them.
A video of two sample lessons is posted on a Vimeo page put together by one of the assessment consortia, the Partnership for Assessment of Readiness for College and Careers, or PARCC. In addition to the lesson on the "Gettysburg Address," the video features Coleman teaching the Rev. Martin Luther King Jr.'s "Letter From a Birmingham Jail." They were presented at a June gathering of states in the consortium as they met to discuss transitioning to the common core.
The other consortium, SMARTER Balanced, pointed me to appendices of its draft content specifications, which offer examples of the kinds of questions students are likely to see on the assessments the group is designing. See Appendix D for the English/language arts, and Appendix C for math. The consortium's "materials and resources" page features the content specifications, but that's the only resource at the moment that could offer real curriculum and instruction guidance to educators.
I see that PARCC has a section of its website devoted to the classroom teacher. It has put its draft content frameworks in there, but the rest of the resources it lists there are described in future tense, including sample instructional units and assessment tasks, a tool to help teachers gauge text complexity, and a course to help high school seniors beef up their skills.
In case you missed it, we wrote about PARCC's draft content frameworks and SMARTER Balanced's content specifications, and about publishers' criteria written for the English/language arts standards. We've mentioned many times the publishing world's clamor to create or adapt materials for the standards. Some folks are creating resources and giving them away for free, such as Common Core's curriculum maps and Core Knowledge's curriculum sequence.
The lead writers of the math common standards are developing an array of things to guide educators, as well, and have now put out a document intended to guide those developing curriculum resources, as well.
It will be interesting to see how many good-quality curriculum and instructional resources are made available to states and districts for free, and how much ends up carrying a price tag. The consortia have articulated plans to make a boatload of resources available for free, in centralized locations (although not without controversy, since some see the federal funding of that work as blurring the line drawn to protect local decisionmaking). How much states and districts will have to invent for themselves, and whether that is actually a good thing, will bear watching.
By their nature, the common standards are shared—states are putting them into practice in their own ways, but with overlapping experiences. And clearly, they are meeting and talking about implementation, through such forums as the CCSSO's common-core implementation group, and the meetings of the states in the assessment consortia (some of those sessions are captured on PARCC's Vimeo site, which I mentioned earlier).
Even as states meet and talk, though, thousands of principals and teachers are trying to figure out how to start teaching to the new standards, and are clearly telling us they need help. Common standards was supposed to be about doing less reinventing the wheel, and more sharing of good stuff. Is it that very few good, aligned curriculum resources are available yet? Or perhaps that they don't have a very high profile? Could it be that the lag time between need and availability is going to prove to be a problem?


- Get Involved
WOMAN'S COLLECTION, TEXAS WOMAN'S UNIVERSITY
WOMAN'S COLLECTION, TEXAS WOMAN'S UNIVERSITY. The Woman's Collection in the Blagg-Huey Library at Texas Woman's University in Denton was established by President Louis H. Hubbard in 1932 and is one of the largest and oldest collections of materials about women's history and issues in the United States. The collection contains approximately 20,000 volumes, 126 subscriptions to women's magazines, 118 manuscript collections, and 27,000 microforms, as well as the 1981 women's history exhibit Texas Women: A Celebration of History, and a museum collection. The book collection, which dates from the eighteenth century, is international in scope but emphasizes American women. It includes printed diaries, letters, and memoirs and materials covering women's history, movements, and involvement in various fields and issues. The periodical collection includes titles on specialized topics and such nineteenth-century historic titles as Godey's Lady's Book. Since the Texas legislature designated the Texas Woman's University collection as the state's official collection on the history of women in 1979, it has become the primary resource on the history of women in Texas. This status is due in large part to its manuscript collections, which contain papers of both individuals and women's organizations. The Texas Women: A Celebration of History Exhibit Archives were originally compiled by the Foundation for Women's Resources to document the contributions of women to Texas history. This collection of photographs and reproductions of articles and documents is the state's most comprehensive source on Texas women.
Two of the most extensive primary resources on Texas women in the manuscript collection are the papers of the Texas Federation of Women's Clubs and the Texas Division of the American Association of University Women and its branches. The federation papers include official records and correspondence and cover the federation's activities from its inception in 1897 to the present. The AAUW collection includes official records and correspondence of the Texas Division and local branches since 1926. The manuscript collection also contains records that document the history of Texas Woman's University, including a bound volume of handwritten minutes of the university's original board of regents, of which Helen M. G. Stoddard, Mary Eleanor Brackenridge, and Eliza S. R. Johnson were members. One of the most complete collections of women's microform sets in the country, including approximately 24,000 books and periodicals and thousands of pamphlets, diaries, and manuscripts can also be found in the Woman's Collection. Two of these are the Gerritsen Collection of Women's History and the History of Women, which together provide international coverage from 1534 to 1976. A museum and exhibit supplement the collection. Artifacts in the Historical Collection document the history of Texas Woman's University and the daily lives of Texas women. The artifacts and informative panels in the Texas Women: A Celebration of History exhibit chronicle the lives of women who have shaped the history, culture, and social conditions of the state.
BIBLIOGRAPHY:Denton Record-Chronicle, March 29, 1989. Mary Beth Rogers, Texas Women: A Celebration of History (Austin: Texas Foundation for Women's Resources, 1981). Elizabeth Snapp, "The Woman's Collection, the Texas Woman's University Library," in Women's Collections, ed. Suzanne Hildenbrand (New York: Haworth, 1986). Joyce Thompson, Marking a Trail: A History of the Texas Woman's University (Denton: Texas Woman's University Press, 1982). Ruthe Winegarten, Finder's Guide to the`Texas Women: A Celebration of History' Exhibit Archives (Denton: Texas Woman's University Library, 1984).
Image Use Disclaimer
All copyrighted materials included within the Handbook of Texas Online are in accordance with Title 17 U.S.C. Section 107 related to Copyright and “Fair Use” for Non-Profit educational institutions, which permits the Texas State Historical Association (TSHA), to utilize copyrighted materials to further scholarship, education, and inform the public. The TSHA makes every effort to conform to the principles of fair use and to comply with copyright law.
For more information go to: http://www.law.cornell.edu/uscode/17/107.shtml
If you wish to use copyrighted material from this site for purposes of your own that go beyond fair use, you must obtain permission from the copyright owner.
The following, adapted from the Chicago Manual of Style, 15th edition, is the preferred citation for this article.Handbook of Texas Online, Metta Nicewarner, "WOMAN'S COLLECTION, TEXAS WOMAN'S UNIVERSITY," accessed April 24, 2019, http://www.tshaonline.org/handbook/online/articles/lcw01.
Uploaded on June 15, 2010. Published by the Texas State Historical Association.


- 1 Introduction
- 2 Preliminaries
- 3 Understanding flow graphs
- 4 A first working code example
- 5 Coding Python GNU Radio Applications
- 6 Advanced Topics
- 7 What next?
Welcome, GNU Radio beginners. If you are reading this tutorial, you probably already have some very basic knowledge about how GNU Radio works, what it is and what it can do - and now you want to enter this exciting world of Open Source digital signal processing (DSP) yourself.
This is a tutorial on how to write applications for GNU Radio in Python using the version 3.7 API. It is no introduction to programming, software radio or signal processing, nor does it cover how to extend GNU Radio by creating new blocks or adding code to the source tree. If you have some background in the mentioned topics and are starting to work with GNU Radio, this probably is the correct tutorial for you. If you don't know what a Software Radio is or what a FIR filter does, you should probably go a few steps back and get a more solid background on signal processing theory. But don't let this discourage you - the best way to learn something is by trying it out.
Although this tutorial is designed to make your introduction to GNU Radio as easy as possible, it is not a definitive guide. In fact, I might sometimes simply not tell the real truth to make explanations easier. I might even contradict myself in later chapters. Usage of brain power is still necessary to develop GNU Radio applications.
Before you get started with this tutorial, make sure your GNU Radio installation is ready and working. You don't necessarily need a USRP, but some kind of source and sink (USRP, audio or other hardware) is helpful, although not strictly required. If the GNU Radio examples work (such as dial_tone.py in gr-audio/examples/python), you're ready to go.
You should also have some background in programming - but don't worry if you've never programmed Python, it is a very easy language to learn.
Understanding flow graphs
Before we start banging out code, first we need to understand the most basic concepts about GNU Radio: flow graphs (as in graph theory) and blocks. Many GNU Radio applications contain nothing other than a flow graph. The nodes of such a graph are called blocks, and the data flows along the edges.
Any actual signal processing is done in the blocks. Ideally, every block does exactly one job - this way GNU Radio stays modular and flexible. Blocks are written in C++; writing new blocks is not very difficult (but explained elsewhere).
The data passing between blocks can be of any kind - practically any type of data you can define in C++ is possible. In practice, the most common data types are complex and real short or long integers and floating point values as most of the time, data passing from one block to the next will either be samples or bits.
In order to illuminate this diffuse topic a little, let's start with some examples:
Low-pass filtered audio recorder
+-----+ +-----+ +----------------+ | Mic +--+ LPF +--+ Record to file | +-----+ +-----+ +----------------+
First, an audio signal from a microphone is recorded by your PCs sound card and converted into a digital signal. The samples are streamed to the next block, the low pass filter (LPF), which could be implemented as an FIR filter. The filtered signal is passed on to the final block, which records the filtered audio signal into a file.
This is a simple, yet complete flow graph. The first and last block serve a special purpose: they operate as source and sink. Every flow graph needs at least one source and sink to be able to function.
Dial tone generator
+------------------------+ | Sine generator (350Hz) +---+ +------------------------+ | +------------+ +---+ | | Audio sink | +---+ | +------------------------+ | +------------+ | Sine generator (440Hz) +---+ +------------------------+
This simple example is often called the "Hello World of GNU Radio". Other than the first example, it has two sources. The sink, on the other hand, has two inputs - in this case for the left and right channel of the sound card. Code for this example is available at gr-audio/examples/python/dial_tone.py.
+-------------+ +----------------+ +------------------+ | USRP Source +--+ Frequency sync +--+ Matched filter | +-------------+ +----------------+ +-----------+------+ | COMPLEX SAMPLES +-------------+------+ | Symbol demodulator | +-------------+------+ | COMPLEX SYMBOLS +-----------------+ +-----------------+ +------+------+ | Source decoder +--+ Channel decoder +--+ Bit mapping | +--------+--------+ +-----------------+ +-------------+ | BITS +--------+--------+ | Application | DATA +-----------------+
This example is a bit more sophisticated, but should look quite familiar to RF engineers. In this case, the source is a USRP which is connected to an antenna. This kind of source sends complex samples to the following blocks.
The interesting part about this kind of flow graph is that the data types change during the flow graph: at first, complex baseband samples are passed along. Then, complex symbols are gathered from the signal. Next, these symbols are turned into bits which again are processed further. Finally, the decoded bits are passed to some application which makes use of the data.
+--------------+ +------------------+ +---------+ +------------+ | USRP Source +--+ NBFM Demodulator +--+ Squelch +--+ Audio Sink | +--------------+ +------------------+ +---------+ +------------+ +--------------+ +----------------+ +------------+ | Audio Source +----------+ NBFM Modulator +---------+ USRP Sink | +--------------+ +----------------+ +------------+
This applications consists of two separate flow graphs, both running in parallel. One of them deals with the Tx path, the other with the Rx path. This kind of application would require some extra code (outside the flow graphs) to mute one path while the other is active. Both flow graphs still require at least one source and sink, each. You can find a GNU Radio application that does this (only a bit more sophisticated) at gr-uhd/examples/python/usrp_nbfm_ptt.py.
This concludes the chapter about flow graphs. Here's a quick summary about the most vital points you really need to know:
- All signal processing in GNU Radio is done through flow graphs.
- A flow graph consists of blocks. A block does one signal processing operation, such as filtering, adding signals, transforming, decoding, hardware access or many others.
- Data passes between blocks in various formats, complex or real integers, floats or basically any kind of data type you can define.
- Every flow graph needs at least one sink and source.
A first working code example
Next step is to find out how to write those flow graphs in real Python. Let's start by examining some code line-by-line. If you are familiar with Python, you can probably skip some of the explanations, but don't rush to the next section yet - the explanations are both for Python and GNU Radio beginners.
The following code example represents the flow graph from example 2. It is actually a slightly modified version of the code example you can find in gr-audio/examples/python/dial_tone.py.
#!/usr/bin/env python from gnuradio import gr from gnuradio import audio, analog class my_top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self) sample_rate = 32000 ampl = 0.1 src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl) src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl) dst = audio.sink(sample_rate, "") self.connect(src0, (dst, 0)) self.connect(src1, (dst, 1)) if __name__ == '__main__': try: my_top_block().run() except [[KeyboardInterrupt]]: pass
The first line should look familiar to anyone with some Unix or Linux background: It tells the shell that this file is a Python file and to use the Python interpreter to run this file. You need this line if you want to run this file directly from the command line.
Lines 3 and 4 import necessary Python modules to run GNU Radio. The
import command is similar to the
#include directive in C/C++. Here, three modules from the gnuradio package are imported:
analog. The first module,
gr, is the basic GNU Radio module. You will always have to import this to run a GNU Radio application. The second loads audio device blocks, and the third is where the blocks related to analog signal functionality and modulation are located. There are many GNU Radio modules, a short list of modules will be presented later on.
Lines 6-17 define a class called
my_top_block which is derived from another class,
gr.top_block. This class is basically a container for the flow graph. By deriving from
gr.top_block, you get all the hooks and functions you need to add blocks and connect them.
Only one member function is defined for this class: the function
__init__(), which is the constructor of this class. In the first line of this function (line 8), the parent constructor is called (in Python, this needs to be done explicitly. Most things in Python need to be done explicitly; in fact, this is one main Python principle).
Next, two variables are defined:
ampl. These will control sampling rate and amplitude of the signal generators.
Before explaining the next lines, have another look at the sketched flow graph chart in the previous section: it consists of three blocks and two edges. The blocks are defined in lines 13-15: Two signal sources are generated (called
src1). These sources continuously create sine waves at given frequencies (350 and 440Hz) and a given sampling rate (here 32kHz). The amplitude is controlled by the ampl variable and set to 0.1. The prefix "f" of the block type
analog.sig_source_f indicates the output is of type
float, which is a good thing because the audio sink accepts floating point samples in the range between 1 and +1. These kind of things must be taken care of by the programmer: although GNU Radio does some checks to make sure the connections make sense, there is still some things that must be taken care of manually. For example, if you wanted to feed integer samples to
audio.sink, GNU Radio would throw an error but if you would set the amplitude in the above example to anything larger than 1, you would get a distorted signal without receiving an error.
The signal sink is defined in line 15:
audio.sink() returns a block which acts as a soundcard control and plays back any samples piped into it. As in the blocks beforehand, the sampling rate needs to be set explicitly, even though this was set already for the signal sources. GNU Radio cannot guess the correct sampling rate from the context, as it is not part of the information flow between blocks.
Lines 16 and 17 connect the blocks. The general syntax for connecting blocks is
self.connect(block1, block2, block3, ...) which would connect the output of
block1 with the input of
block2, the output of
block2 with the input of
block3 and so on. You can connect as many blocks as you wish with one
connect() call. Here, a special syntax is necessary because we want to connect
src0 with the first input of
src1 with the second one.
self.connect (src0, (dst, 0)) does exactly this: it specifically connects
src0 to port 0 of
(dst, 0) is called a "tuple" in Python jargon. In the
self.connect() call it is used to specify the port number. When the port number is zero, the block may be used alone. An equivalent command to the one in line 16 would thus have been
self.connect((src0, 0), (dst, 0))
That's all there is to create a flow graph. The last 5 lines do nothing but start the flow graph (line 22). The
except statements simply make sure the flow graph (which would otherwise run infinitely) are stopped when Ctrl+C is pressed (which triggers a
KeyboardInterrupt Python exception).
For Python-beginners, two more remarks should not be left out: As you might have noticed, the class my_top_block is run without creating an instance beforehand. In Python, this is a quite common thing to do, especially if you have a class which would only get one instance anyway. However, you could just as well create one or more instances of the class and then call the
run() method on the instance(es).
Second, the indenting is part of the code and not, like in C++, simply for the programmers convenience. If you try and modify this code, make sure you don't start mixing tabs and spaces. Every level must be consistently indented.
If you want to go on with this tutorial, you should first get a more solid Python background. Python documentation can be found at the Python web site http://www.python.org/, or a library of your choice. A good place to start for people with prior programming experience is http://wiki.python.org/moin/BeginnersGuide/Programmers .
- You need to import required GNU Radio modules with the
from gnuradio importcommand. You always need the module
- A flow graph is contained in a class which itself is derived from
- Blocks are created by calling functions such as
analog.sig_source_f()and saving the return value to a variable.
- Blocks are connected by calling
self.connect()from within the flow graph class
- If you don't feel comfortable writing some basic Python code now, have a break and go through some Python tutorials.
The next section will give a more detailed overview about writing GNU Radio applications in Python.
Coding Python GNU Radio Applications
The example above already covers quite a lot of how to write Python GNU Radio applications. This chapter and the next will try to show the possibilities of GNU Radio applications and how to use them. From now on, there is no need to linearly read these chapters section-for-section, it probably makes more sense to go over the titles and find out what you want to know.
GNU Radio Modules
GNU Radio comes with quite a lot of libraries and modules. You will usually include modules with the following syntax:
from gnuradio import MODULENAME
Some modules work a bit differently, see the following list on the most common modules.
|gr||The main GNU Radio library. You will nearly always need this.|
|analog||Anything related to analog signals and analog modulation|
|audio||Soundcard controls (sources, sinks). You can use this to send or receive audio to the sound cards, but you can also use your sound card as a narrow band receiver with an external RF frontend.|
|blocks||Everything else. If it doesn't fit in another category, it's probably here.|
|channels||Channel models for simulation.|
|digital||Anything related to digital modulation.|
|fec||Anything related to Forward Error Correction (FEC).|
|fft||Anything related to FFTs.|
|filter||Filter blocks and design tools like firdes and optfir.|
|plot_data||Some functions to plot data with Matplotlib|
|qtgui||Graphical tools to plot data (time, frequency, spectrogram, constellation, histogram, time raster) using the QT library.|
|trellis||Blocks and tools for building trellis, trellis coded modulation, and other FSMs.|
|vocoder||Anything dealing with voice coding/decoding.|
|wavelet||Anything dealing with wavelets.|
|wxgui|| This is actually a submodule, containing utilities to quickly create graphical user interfaces to your flow graphs. Use
|eng_notation||Adds some functions to deals with numbers in engineering notation such as @100M' for 100 * 10^6'.|
|gru||Miscellaneous utilities, mathematical and others.|
This is by far not a complete list, nor are the descriptions of the modules very useful by themselves. GNU Radio code changes a lot, so creating a static documentation would not be very sensible. GNU Radio uses Doxygen and Sphinx to dynamically create documentation of the APIs.
Instead, you will have to use the good old Star Wars motto to delve further into the details of the modules: "Use the source!". If you feel GNU Radio should really already have some functionality you want to use, either browse through the module directory Python uses or go through the source directory of GNU Radio. In particular, pay attention to the directories starting with
gr- in the source directory, such as gr-trellis. These produce their own code and, consequently, their own modules.
Of course, Python itself comes with a lot of modules, some of which are extremely useful - if not necessary - to write GNU Radio applications. Check the Python documentation and the SciPy website for more information.
Choosing, defining and configuring blocks
GNU Radio comes with an abundance of pre-defined blocks, so for beginners, it is often quite confusing to find the correct blocks for their applications and set them up correctly. Doxygen and Sphinx are used to automatically generate documentation for the C++ and Python APIs (C++ Manual, Python Manual.
You can also generate this documentation locally so it always matches the version you have installed. If you have Doxygen and Sphinx installed, CMake takes care of this automatically.
Learning how to use these documentations is a major part of learning how to use GNU Radio!
Let's get practical. Here's the three lines from the previous example which define the blocks:
src0 = analog.sig_source_f (sample_rate, analog.GR_SIN_WAVE, 350, ampl) src1 = analog.sig_source_f (sample_rate, analog.GR_SIN_WAVE, 440, ampl) dst = audio.sink (sample_rate, "")
Here's a simplified version of what happens when this code is executed: First, a function called
sig_source_f in the module
analog is executed. It receives four function arguments:
- sample_rate, which is a Python variable,
- analog.GR_SIN_WAVE, which is a constant defined in the
analogmodule (defined here,
- 350, a normal literal constant that's the frequency of the sine wave (relative to the sample rate),
- ampl, another variable to set the amplitude of the sine wave.
This function creates a class which is subsequently assigned to
src0. The same happens on the other two lines, although the sink is fetched from a different module (
So how did I know which block to use and what to pass to
analog.sig_source_f()? This is where the documentation comes in. If you use the Sphinx-generated docs, click on "gnuradio.analog". Proceed to "Signal Sources". You will find a list of signal generators, including the
sig_source_* family. The suffix defines the data type at the output:
- f = float
- c = complex float
- i = int
- s = short int
- b = bits (actually an integer type)
These suffixes are used for all types of blocks, e.g.
filter.fir_filter_ccf() will define an FIR filter with complex input, complex output and float taps, and
blocks.add_const_ss() will define a block which adds incoming short values with another, constant, short int.
Even if you don't want to touch C+, it's worth having a look at the Doxygen-generated documentation as well, since most of the blocks are actually written in C+ but then exported to Python.
At this point, it is worth having a closer look behind the curtains of GNU Radio. The reason you can easily use the blocks - written in C++ - in your Python code is because GNU Radio uses a tool called SWIG to create an interface between Python and C+. Every block in C+ comes with a creating function, called
gr::analog::sig_source_f::make() in the example mentioned above). This function is always documented on the same page as the matching class, and this function is what gets exported to Python, so
analog.sig_source_f() in Python calls
gr::analog::sig_source_f::make() in C++. For the same reason, it takes the same arguments - that's how you know how to initialize a block in Python.
Once you're browsing the Doxygen documentation of the class
gr::analog::sig_source_f, you might notice many other class methods, such as
set_frequency(). These functions get exported to Python as well. So if you have created a signal source and want to change the frequency (say your application has a user frequency control) you can use this method on your Python defined block:
# We're in some cool application here src0 = analog.sig_source_f (sample_rate, analog.GR_SIN_WAVE, 350, ampl) # Other, fantastic things happen here src0.set_frequency(880) # Change frequency
will change the frequency of the first signal generator to 880Hz.
Hopefully, GNU Radio documentation will grow and become more and more complete. But to completely understand the workings of blocks in detail, you will probably have to have a look at the code sooner or later, no matter how good the documentation gets.
connect() method of
gr.top_block to connect blocks. Some things are worth mentioning:
- You can only connect inputs and outputs if the data types match. If you try to connect a float output with a complex input, you will get an error.
- One output can be connected to several inputs; you don't need an extra block to duplicate signal paths.
These are basic rules for connecting blocks and they work in most cases. However, when mixing data types some more notes are worth mentioning.
- GNU Radio checks if input and output types match by checking their size. If you happen to connect up ports with different types but the same size, you will most definitely get data junk.
- When processing single bits, be careful. In some cases, you will work with binary data in a usual sense, in other cases you want to handle a specific number of bits at a time. Have a look at the
unpacked_to_packed*blocks for this.
- Be careful with dynamic ranges. When you're using float or complex data types, you have a larger range than you'll ever need concerning the machine, but some sinks and sources have specific ranges you need to stick to. For example, audio sinks require samples within -1 and will clip anything outside this interval. The USRP sink on the other hand needs samples in the-32767 range (signed 16 bit values) because that's the dynamic range of the DAC.
Sometimes it makes sense to combine several blocks into a new block. Say you have several applications which all have a common signal processing component which consists of several blocks. These blocks can be combined into a new block, which in turn can be used in your applications is if it were a normal GNU Radio block.
Example: Say you have two different flow graphs, FG1 and FG2. Both use - among others - the blocks B1 and B2. You want to combine them to a hierarchical block called
+-------------------+ | +-----+ +----+ | --+--+ B1 +--+ B2 +--+--- | +-----+ +----+ | | HierBlock | +-------------------+
This is what you do: create a flow graph which derives from
gr.hier_block2 and use
self as source and sink:
class HierBlock(gr.hier_block2): def __init__(self, audio_rate, if_rate): gr.hier_block2.__init__(self, "HierBlock", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(1, 2, gr.sizeof_gr_complex)) B1 = blocks.block1(...) # Put in proper code here! B2 = blocks.block2(...) self.connect(self, B1, B2, self)
As you can see, creating a hierarchical block is very similar to creating a flow graph with
gr.top_block. Apart from using
self as source and sink, there is another difference: the constructor for the parent class (called in line 3) needs to receive additional information. The call to
gr.hier_block2.+init+() takes four parameters:
- self (which is always passed to the constructor as first argument),
- a string with an identifier for the hierarchical block (change at your convenience),
- an input signature and an
- output signature.
The last two require some extra explanation unless you have already written your own blocks in C++. GNU Radio needs to know what types of input and output the block uses. Creating an input/output signature can be done by calling
gr.io_signature(), as is done here. This function call takes 3 arguments:
- minimum number of ports,
- maximum number of ports and
- size of the input/output elements.
For the hierarchical block
HierBlock, you can see that it has exactly one input and one or two outputs. The incoming objects are of size
float, so the block processes incoming real float values. Somewhere in B1 or B2, the data is converted to complex float values, so the output signature declares outgoing objects to be of size
gr.sizeof_gr_complex. The 'gr.sizeof_float@ and
gr.sizeof_gr_complex are equivalent to the C++ return values of the
sizeof() call. Other predefined constants are
Use gr.io_signature(0, 0, 0) to create a null IO signature, i.e. for defining hierarchical blocks as sources or sinks.
That's all. You can now use
HierBlock as you would use a regular block. For example, you could put this code in the same file:
class FG1(gr.top_block): def __init__(self): gr.top_block.__init__(self) ... # Sources and other blocks are defined here other_block1 = blocks.other_block() hierblock = HierBlock() other_block2 = blocks.other_block() self.connect(other_block1, hierblock, other_block2) ... # Define rest of FG1
Of course, to make use of Pythons modularity, you could also put the code for
HierBlock in an extra file called
hier_block.py. To use this block from another file, simply add an import directive to your code:
from hier_block import HierBlock
and you can use
HierBlock as mentioned above.
Examples for hierarchical blocks:
gr-uhd/examples/python/fm_tx_2_daughterboards.py gr-uhd/examples/python/fm_tx4.py gr-digital/examples/narrowband/tx_voice.py
Multiple flow graphs
In some cases, you might want to have completely separate flow graphs, e.g. for receive and transmit paths (see the example 'Walkie-Talkie' above). Currently (June 2008), it is not possible to have multiple top_blocks running at the same time, but what you can do is create full flow graphs as hierarchical blocks using
gr.hier_block2 like in the section above. Then, create a top_block to hold the flow graphs.
class transmit_path(gr.hier_block2): def __init__(self): gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), # Null signature gr.io_signature(0, 0, 0)) source_block = blocks.source() signal_proc = blocks.other_block() sink_block = blocks.sink() self.connect(source_block, signal_proc, sink_block) class receive_path(gr.hier_block2): def __init__(self): gr.hier_block2.__init__(self, "receive_path", gr.io_signature(0, 0, 0), # Null signature gr.io_signature(0, 0, 0)) source_block = blocks.source() signal_proc = blocks.other_block() sink_block = blocks.sink() self.connect(source_block, signal_proc, sink_block) class my_top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self) tx_path = transmit_path() rx_path = receive_path() self.connect(tx_path) self.connect(rx_path)
Now, when you start
my_top_block, both flow graphs are started in parallel. Note that the hierarchical blocks have explicitly no inputs and outputs defined, they have a null IO signature. Consequently, they don't connect to
self as source or sink; they rather define their own sources or sink (just as you would do when defining a hierarchical block as source or sink). The top block simply connects the hierarchical blocks to itself, but does not connect them up in any way.
Examples for multiple flow graphs:
GNU Radio extensions and tools
GNU Radio is more than blocks and flow graphs - it comes with a lot of tools and code to help you write DSP applications.
A collection of useful GNU Radio applications designed to aid you is in gr-utils/.
Browse the source code in gnuradio-runtime/python/gnuradio (and other gr-<component>/python directories) to find utilities you can use in your Python code such as filter design code, modulation utilities, and more.
Controlling flow graphs
If you have followed the tutorial so far, you will have noticed that a flow graph has always been implemented as a class, derived from
gr.top_block. The question remains on how to control one of these classes.
As mentioned before, deriving the class from gr.top_block brings along all the functionality you might need. To run or stop an existing flow graph, use the following methods:
||The simplest way to run a flow graph. Calls start(), then wait(). Used to run a flow graph that will stop on its own, or to run a flow graph indefinitely until SIGINT is received.|
||Start the contained flow graph. Returns to the caller once the threads are created.|
||Stop the running flow graph. Notifies each thread created by the scheduler to shutdown, then returns to caller.|
||Wait for a flow graph to complete. Flowgraphs complete when either (1) all blocks indicate that they are done, or (2) after stop has been called to request shutdown.|
||Lock a flow graph in preparation for reconfiguration.|
||Unlock a flow graph in preparation for reconfiguration. When an equal number of calls to lock() and unlock() have occurred, the flow graph will be restarted automatically.|
See the documentation for
gr::top_block for more details.
class my_top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self) ... # Define blocks etc. here if __name__ == '__main__': my_top_block().start() sleep(5) # Wait 5 secs (assuming sleep was imported!) my_top_block().stop() my_top_block().wait() # If the graph is needed to run again, wait() must be called after stop ... # Reconfigure the graph or modify it my_top_block().start() # start it again sleep(5) # Wait 5 secs (assuming sleep was imported!) my_top_block().stop() # since (assuming) the graph will not run again, no need for wait() to be called
These methods help you to control the flow graph from the outside. For many problems this might not be enough: you don't simply want to start or stop a flow graph, you want to reconfigure the way it behaves. For example, imagine your application has a volume control somewhere in your flow graph. This volume control is implemented by inserting a multiplier into the sample stream. This multiplier is of type
blocks.multiply_const_ff. If you check the documentation for this kind of of block, you will find a function
blocks.multiply_const_ff.set_k() which sets the multiplication factor.
You need to make the settings visible to the outside in order to control it. The simplest way is to make the block an attribute of the flow graph class.
class my_top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self) ... # Define some blocks self.amp = blocks.multiply_const_ff(1) # Define multiplier block ... # Define more blocks self.connect(..., self.amp, ...) # Connect all blocks def set_volume(self, volume): self.amp.set_k(volume) if __name__ == '__main__': my_top_block().start() sleep(2) # Wait 2 secs (assuming sleep was imported!) my_top_block.set_volume(2) # Pump up the volume (by factor 2) sleep(2) # Wait 2 secs (assuming sleep was imported!) my_top_block().stop()
This example runs the flow graph for 2 seconds and then doubles the volume by accessing the
amp block through a member function called
set_volume(). Of course, one could have accessed the
amp attribute directly, omitting the member function.
Hint: making blocks attributes of the flow graph is generally a good idea as it makes extending the flow graph with extra member functions easier.
Non-flow graph centered applications
Up until now, GNU Radio applications in this tutorial have always been centered around the one class derived from
gr.top_block. However, this is not necessarily how GNU Radio needs to be used. GNU Radio was designed to develop DSP applications from Python, so there's no reason to not use the full power of Python when using GNU Radio.
Python is an extremely powerful language, and new libraries and functionalities are constantly being added. In a way, GNU Radio extends Python with a powerful, real-time-capable DSP library. By combining this with other libraries you have immense functionality right there at your fingertips. For example, by combining GNU Radio with SciPy, a collection of scientific Python libraries, you can record RF signals in real time and do extensive mathematical operations off line, save statistics to a database and so on - all in the same application. Even expensive engineering software such as Matlab might become unnecessary if you combine all these libraries.
If you have really read the previous sections, you already know enough to write your first Python GNU Radio applications. This section will address some slightly more advanced functionalities for Python GNU Radio applications.
Dynamic flow graph creation
For most cases, the aforementioned way to define flow graphs is completely adequate. If you need more flexibility in your application, you might want to have even more control over the flow graph from outside the class.
This can be achieved by taking the code out of the
+init+() function and simply using
gr.top_block as a container. Example:
... # We are inside some application tb = gr.top_block() # Define the container block1 = blocks.some_other_block() block2 = blocks.yet_another_block() tb.connect(block1, block2) ... # The application does some wonderful things here tb.start() # Start the flow graph ... # Do some more incredible and fascinating stuff here
If you are writing some application which needs to dynamically stop a flow graph (reconfigure it, re-start it and so) on this might be a more practical way to do it.
Examples for this kind of flow graph setup:
Command Line Options
Python has its own libraries to parse command line options. See the documentation for the module
optparse to find out how to use it.
GNU Radio extends optparse by new command line option types. Use @from gnuradio.eng_option import eng_option' to import this extension. With eng_option, you have the following types:
|eng_float||Like the original float option, but also accepts engineering notation like 101.8M|
|subdev||Only accepts valid subdevice descriptors such as A:0 (To specify a daughterboard on a USRP)|
|intx||Only accepts integers|
If your application supports command line options, it would be ever so nice if you could stick to the GNU Radio conventions for command line options. You can find these (along with more hints for developers) in README.hacking.
Nearly every GNU Radio example uses this feature. Try dial_tone.py for an easy example.
Graphical User Interfaces
If you are a Python expert and also have some experience in writing GUIs for Python (using whatever GUI toolkit you like), you might not even need this section. As mentioned before, GNU Radio merely extends Python with DSP routines - so if you like, just go ahead and write a GUI application, add a GNU Radio flow graph to it and define some interfaces to carry GNU Radio information to your application and vice versa. If you want to plot your data, you could use Matplotlib or Qwt.
However, sometimes you simply want to write a quick GUI application without bothering with setting up widgets, defining all the menus etc. GNU Radio comes with some predefined classes to help you write graphical GNU Radio applications.
These modules are based on wxWidgets (or to be precise, wxPython), a platform-independent GUI toolkit. You will need some background in wxPython - but don't worry, it is not that complicated and there are several tutorials available on the net. Check the wxPython website for documentation (http://www.wxpython.org/).
To use the GNU Radio wxWidgets tools, you need to import some modules:
from gnuradio.wxgui import stdgui2, fftsink2, slider, form
Here, 4 components were imported from the gnuradio.wxgui submodule. Here's a quick list of the modules (again, not necessarily complete. You will have to browse the modules or the source code in gr-wxgui/python).
|stdgui2||Basic GUI stuff, you always need this|
|fftsink2||Plot FFTs of your data to create spectrum analyzers or whatever|
|numbersink2||Displays numerical values of incoming data|
|form||Often used input forms (see below)|
Next, we have to define a new flow graph. This time, we don't derive from
gr.top_block but from
class my_gui_flow_graph(stdgui2.std_top_block): def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
As you can see, there's another difference: the constructor gets a couple of new parameters. This is because a
stdgui2.std_top_block does not only include flow graph functionality (it is derived from gr.top_block itself), but also directly creates a window with some basic components (like a menu). This is good news for all of those who just want to quickly hack a graphical application: GNU Radio creates the window and everything, you just need to add the widgets. Here's a list of what you can do with these new objects (this probably won't mean much to you if you have no idea about GUI programming):
|frame||The wx.Frame of your window. You can get at the predefined menu by using frame.GetMenuBar()|
|panel||A panel, placed in @frame', to hold all your wxControl widgets|
|vbox||A vertical box sizer (wx.BoxSizer(wx.VERTICAL) is how it is defined), used to align your widgets in the panel|
|argv||The command line arguments|
Now you have all you need to create your GUI. You can simply add new box sizers and widgets to vbox, change the menu or whatever. Some typical functions have been simplified further in the GNU Radio GUI library
form has a great number of input widgets:
form.static_text_field() for static text field (display only),
form.float_field(), to input float values,
form.text_field() to input text,
form.checkbox_field() for checkboxes,
form.radiobox_field() for radioboxes etc. Check the source code of gr-wxgui/python/form.py for the complete list. Most of these calls pass most of their arguments to the appropriate wxPython objects, so the function arguments are quite self-explanatory.
See one of the examples mentioned below on how to add widgets using form.
Probably the most useful part of
gnuradio.wxgui is the possibility to directly plot incoming data. To do this, you need one of the sinks that come with
gnuradio.wxgui, such as
fftsink2. These sinks work just as any other GNU Radio sink, but also have properties needed for use with wxPython. Example:
from gnuradio.wxgui import stdgui2, fftsink2 # App gets defined here ... # FFT display (pseudo-spectrum analyzer) my_fft = fftsink2.fft_sink_f(panel, title="FFT of some Signal", fft_size=512, sample_rate=sample_rate, ref_level=0, y_per_div=20) self.connect(source_block, my_fft) vbox.Add(my_fft.win, 1, wx.EXPAND)
First, the block is defined (
fftsink2.fft_sink_f). Apart from typical DSP parameters such as the sampling rate, it also needs the
panel object which is passed to the constructor. Next, the block is connected to a source. Finally, the FFT window (
my_fft.win) is placed inside the
vbox BoxSizer to actually display it. Remember that a signal block output can be connected to any amount of inputs.
Finally, the whole thing needs to be started. Because we need an
wx.App() to run the GUI, the start-up code is a bit different from a regular flow graph:
if __name__ == '__main__': app = stdgui2.stdapp(my_gui_flow_graph, "GUI GNU Radio Application") app.MainLoop()
stdgui2.stdapp() creates the
my_gui_flow_graph (the first argument). The window title is set to "GUI GNU Radio Application".
Examples for simple GNU Radio GUIs:
gr-uhd/apps/uhd_fft gr-audio/examples/python/audio_fft.py ./gr-uhd/examples/python/usrp_am_mw_rcv.py
And many more.
Young Padawan, no more there is I can teach you. If you have any more questions on how to write GNU Radio applications in Python, there are still a number of resources you can use:
- Use the source. Especially the examples in gr-<component>/examples/ and gr-utils/ can be very helpful.
- Check the mailing list archives. Chances are very high your problem has been asked before.


Once Upon a Time in America
The movie is set at three different times;
- the early 1920s; the characters as children,
- the early 1930s; the characters as adults,
- 1968; the few still living characters in their old age.
When Leone finished making the movie it was 229 minutes (3 hours and 49 minutes) and started with an old character (Robert De Niro) remembering his past; it then showed him as a child and as a young adult. We call this flashbacks; it can happen in movie but certainly not in real life. But when it was first shown to American audiences it was made much shorter and set in chronological order; meaning the movie first showed the characters as children, then as young adults and then as older adults; or 'from start to finish'. We call this chronological; this is what would happen in real life. Many people agree that the longer version is much better than the shortened chronological version.


Origami bases are sequences of folds which are used over and over again in different origami models. Instead of describing the same steps over and over again, an origami author or creator might just say, “Start with Waterbomb Base” and then expect that you know what a Waterbomb Base is.
Different origami books will have different bases which are related to the models found in that particular book. So, there could be many, many different bases. However, there only a handful of origami bases are universally accepted by all origami enthusiasts. These include:
In other countries, origami bases may have different names, but one look at the sequence of folds will tell you that they are one and the same.


Below is important information about CPR.
Cardiopulmonary Resuscitation (CPR)
Less than one-third of out-of-hospital sudden cardiac arrest victims receive bystander CPR.
Effective bystander CPR, provided immediately after sudden cardiac arrest, can double or triple a victim's chance of survival. Administering chest compressions only is more effective than doing nothing at all.
The most effective rate for chest compressions is greater than 100 compressions per minute - the same rhythm as the beat of the BeeGee's song, "Stayin' Alive."
Automated External Defibrillators (AEDs)
Unless CPR and defibrillation are provided within minutes of collapse, few attempts at resuscitation are successful.
Even if CPR is performed, defibrillation with an AED is required to stop the abnormal rhythm and restore a normal heart rhythm.
New technology has made AEDs simple and user-friendly. Clear audio and visual cues tell users what to do when using an AED and coach people through CPR. A shock is delivered only if the victim needs it.
AEDs are now widely available in public places such as schools, airports, and workplaces.
Sudden Cardiac Arrest
EMS treats about 300,000 victims of out-of-hospital cardiac arrest each year in the U.S.
Less than 8% of people who suffer cardiac arrest outside the hospital survive.
Sudden cardiac arrest can happen to anyone at any time. Many victims appear healthy with no known heart disease or other risk factors.
Sudden cardiac arrest is not the same as a heart attack. Sudden cardiac arrest occurs when electrical impulses in the heart become rapid or chaotic, which causes the heart to suddenly stop beating. A heart attack occurs when the blood supply to part of the heart muscle is blocked. A heart attack may cause cardiac arrest.
Teens / Youth
About 5,900 children 18 years old and under suffer out-of-hospital cardiac arrest each year from all causes - including trauma, cardiovascular causes and sudden infant death syndrome.
The incidence of out-of-hospital sudden cardiac arrest in high school athletes ranges from .28 to 1 death per 100,000 high school athletes annually in the U.S.
The American Heart Association does not have a minimum age requirement for people to learn CPR. The ability to perform CPR is based more on body strength rather than age.
Studies have shown that children as young as 9 years old can learn and retain CPR skills.
Cardiac Arrest Videos
The videos below provide a basic overview of what to do in an emergency.
Adult Chain of Survival
The links in the new American Heart Association Emergency Cardiovascular Care Adult Chain of Survival are as follows:
Immediate recognition of cardiac arrest and activation of the emergency response system


Conceived in Liberty
There's never been a better time to remember the revolutionary and even libertarian roots of the American founding, and there's no better guide to what this means in the narrative of the Colonial period than Murray Rothbard.
For anyone who thinks of Murray Rothbard as only an economic theorist or political thinker, this giant book is something of a surprise. It is probably his least known treatise. It offers a complete history of the Colonial period of American history, a period lost to students today, who are led to believe American history begins with the US Constitution.
Rothbard's ambition was to shed new light on Colonial history and show that the struggle for human liberty was the heart and soul of this land from its discovery through the culminating event of the American Revolution. These volumes are a tour de force, enough to establish Rothbard as one of the great American historians.
It is a detailed narrative history of the struggle between liberty and power, as we might expect, but it is more. Rothbard offers a third alternative to the conventional interpretive devices. Against those on the right who see the American Revolution as a "conservative" event, and those on the left who want to invoke it as some sort of proto-socialist uprising, Rothbard views this period as a time of accelerating libertarian radicalism. Through this prism, Rothbard illuminates events as never before.
The original four volumes were published in the 1970s, but the odd timing and uneven distribution prevented any kind of large audience. They were beloved only by a few specialists, and sought after by many, thanks to their outstanding reputation. The Mises Institute is pleased to be the publisher of this integrated edition.
This single volume covers the discovery of the Americas and the colonies in the 17th century, the period of "salutary neglect" in the first half of the 18th century, the advance to revolution, from 1760-1775 and the political, military, and ideological history of the revolution and after.
Auburn, AL: Mises Institute 2011


Jemez Mountain Riparian Forest ReVegetation
Year of Project: 2012
Name of Project: Jemez Mountain Riparian Forest Re-Vegetation
Number of Trees to be Planted: 0
Location: New Mexico
Project Name: Jemez Mountain Riparian Forest Re-Vegetation
Location: Santa Fe National Forest and Valles Caldera National Preserve
Number of Trees: 100,000
Since October 2010, parts of New Mexico, along with the rest of the Southwest, have experienced a drought that most experts expect to last through most of 2012.
One way to protect the precious remaining water is to care for and restore the state’s forests and trees:
- Trees stabilize waterways. Trees’ roots hold the soil in place along streambeds, keeping the water flowing smoothly and slowly downstream. When vegetation is lacking along a stream’s shores, the force of the water erodes the soil, the stream loses definition and less water is carried downstream. The water that does make it downstream is filled with more sediment, which lessens water quality and compromises the health of aquatic species.
- Trees make the water cleaner. When rain falls, it accumulates pollutants from the air and from the ground. When rain falls on trees, their leaves intercept the water, letting it evaporate into the air or slowly trickle down to the soil. Once the water reaches the soil, the tree’s roots help filter it before it enters the adjoining river or stream.
- Trees cool and shade the water. Cooler water evaporates less, and many aquatic species need cooler water to thrive.
Recognizing the important benefit of trees to water quality and quantity in streams and rivers, American Forests is partnering with WildEarth Guardians in 2012 to reforest areas along some of New Mexico’s streams. From aspens to willows to dogwoods and more, 100,000 will be planted along three streams in the upper headwaters of the Jemez Mountains — Rito Penas Negras, Rio San Antonio and Rito de los Indios. These plantings will restore areas damaged from livestock grazing and off-highway vehicles and will improve water quality.


Plantar fasciitis (fashee-EYE-tiss) is the most common cause of pain on the bottom of the heel. Approximately 2 million patients are treated for this condition every year.
Plantar fasciitis occurs when the strong band of tissue that supports the arch of your foot becomes irritated and inflamed.
The plantar fascia is a long, thin ligament that lies directly beneath the skin on the bottom of your foot. It connects the heel to the front of your foot, and supports the arch of your foot.
The plantar fascia is designed to absorb the high stresses and strains we place on our feet. But, sometimes, too much pressure damages or tears the tissues. The body's natural response to injury is inflammation, which results in the heel pain and stiffness of plantar fasciitis.
In most cases, plantar fasciitis develops without a specific, identifiable reason. There are, however, many factors that can make you more prone to the condition:
Although many people with plantar fasciitis have heel spurs, spurs are not the cause of plantar fasciitis pain. One out of 10 people has heel spurs, but only 1 out of 20 people (5%) with heel spurs has foot pain. Because the spur is not the cause of plantar fasciitis, the pain can be treated without removing the spur.
The most common symptoms of plantar fasciitis include:
After you describe your symptoms and discuss your concerns, your doctor will examine your foot. Your doctor will look for these signs:
Your doctor may order imaging tests to help make sure your heel pain is caused by plantar fasciitis and not another problem.
X-rays provide clear images of bones. They are useful in ruling out other causes of heel pain, such as fractures or arthritis. Heel spurs can be seen on an x-ray.
Other Imaging Tests
Other imaging tests, such as magnetic resonance imaging (MRI) and ultrasound, are not routinely used to diagnose plantar fasciitis. They are rarely ordered. An MRI scan may be used if the heel pain is not relieved by initial treatment methods.
More than 90% of patients with plantar fasciitis will improve within 10 months of starting simple treatment methods.
Rest. Decreasing or even stopping the activities that make the pain worse is the first step in reducing the pain. You may need to stop athletic activities where your feet pound on hard surfaces (for example, running or step aerobics).
Ice. Rolling your foot over a cold water bottle or ice for 20 minutes is effective. This can be done 3 to 4 times a day.
Nonsteroidal anti-inflammatory medication. Drugs such as ibuprofen or naproxen reduce pain and inflammation. Using the medication for more than 1 month should be reviewed with your primary care doctor.
Exercise. Plantar fasciitis is aggravated by tight muscles in your feet and calves. Stretching your calves and plantar fascia is the most effective way to relieve the pain that comes with this condition.
Cortisone injections. Cortisone, a type of steroid, is a powerful anti-inflammatory medication. It can be injected into the plantar fascia to reduce inflammation and pain. Your doctor may limit your injections. Multiple steroid injections can cause the plantar fascia to rupture (tear), which can lead to a flat foot and chronic pain.
Supportive shoes and orthotics. Shoes with thick soles and extra cushioning can reduce pain with standing and walking. As you step and your heel strikes the ground, a significant amount of tension is placed on the fascia, which causes microtrauma (tiny tears in the tissue). A cushioned shoe or insert reduces this tension and the microtrauma that occurs with every step. Soft silicone heel pads are inexpensive and work by elevating and cushioning your heel. Pre-made or custom orthotics (shoe inserts) are also helpful.
Night splints. Most people sleep with their feet pointed down. This relaxes the plantar fascia and is one of the reasons for morning heel pain. A night splint stretches the plantar fascia while you sleep. Although it can be difficult to sleep with, a night splint is very effective and does not have to be used once the pain is gone.
Physical therapy. Your doctor may suggest that you work with a physical therapist on an exercise program that focuses on stretching your calf muscles and plantar fascia. In addition to exercises like the ones mentioned above, a physical therapy program may involve specialized ice treatments, massage, and medication to decrease inflammation around the plantar fascia.
Extracorporeal shockwave therapy (ESWT). During this procedure, high-energy shockwave impulses stimulate the healing process in damaged plantar fascia tissue. ESWT has not shown consistent results and, therefore, is not commonly performed.
ESWT is noninvasive-it does not require a surgical incision. Because of the minimal risk involved, ESWT is sometimes tried before surgery is considered.
Surgery is considered only after 12 months of aggressive nonsurgical treatment.
Gastrocnemius recession. This is a surgical lengthening of the calf (gastrocnemius) muscles. Because tight calf muscles place increased stress on the plantar fascia, this procedure is useful for patients who still have difficulty flexing their feet, despite a year of calf stretches.
In gastrocnemius recession, one of the two muscles that make up the calf is lengthened to increase the motion of the ankle. The procedure can be performed with a traditional, open incision or with a smaller incision and an endoscope, an instrument that contains a small camera. Your doctor will discuss the procedure that best meets your needs.
Complication rates for gastrocnemius recession are low, but can include nerve damage.
Plantar fascia release. If you have a normal range of ankle motion and continued heel pain, your doctor may recommend a partial release procedure. During surgery, the plantar fascia ligament is partially cut to relieve tension in the tissue. If you have a large bone spur, it will be removed, as well. Although the surgery can be performed endoscopically, it is more difficult than with an open incision. In addition, endoscopy has a higher risk of nerve damage.
Complications. The most common complications of release surgery include incomplete relief of pain and nerve damage.
Recovery. Most patients have good results from surgery. However, because surgery can result in chronic pain and dissatisfaction, it is recommended only after all nonsurgical measures have been exhausted.


Prevalence, Definitions, and Characteristics
Individuals with hearing impairments make up .11% of the school-age population, and 1.2% of the students served under IDEA (U.S. Department of Education, 2005). Hearing impairments range in severity from mild to moderate to severe to profound, with the greatest educational distinctions occurring between hard of hearing and deaf. Individuals classified as hard of hearing can hear speech tones when wearing hearing aids, while persons who are deaf cannot hear even with hearing aids.
The age that a child loses hearing affects the degree of language delay and development. Children who are born with deafness have congenital hearing losses (prelingual) and more difficulty with language development than those who acquire deafness after age 2 (postlingual).
Pure tone audiometers are used to assess hearing ability. Tones with different pitches (or frequency measured in Hertz [Hz]) and volume (measured in decibels [dB]) are presented via headphones, and individuals raise their hand when they hear a sound. Levels of hearing impairment are classified along a continuum, with reference to zero dB indicating the quietest sound a person with normal hearing can detect. Individuals with slight hearing losses (27–40 dB) may not have difficulty in most school situations. Individuals with mild losses (41–55) may miss up to 50% of classroom discussion if voices are faint or faces cannot be seen. Individuals with moderate losses (56–70 dB) can understand only loud speech, and may have limited vocabularies. Individuals with severe losses (71–90 dB) may be able to hear loud voices within one foot from the ear, and speech is likely to be impaired. Individuals with profound losses (> 90 dB) may hear some loud sounds, but are more likely to sense vibrations, and may rely on vision rather than hearing as a primary vehicle for communication (Heward, 2006). Specialized tests are needed to accurately assess the cognitive and academic functioning of individuals with hearing impairments (Owens, Metz, & Haas, 2003).
Causes of hearing impairments include heredity, prenatal infections such as maternal rubella, ear infections, meningitis, head trauma, prematurity, and oxygen deprivation. Impairments can be conductive, meaning the outer or middle ear along the passageway are damaged; sensorineural, referring to inner ear damage; or they can be a combination of the two (Owens, Metz, & Haas, 2003).
Many children with hearing impairments have academic and cognitive deficiencies or developmental lags due to difficulties processing language (Meadow-Orlans, 1990). Some children experience social-emotional functioning difficulties due to communication difficulties (Luterman, 1996).
An ongoing debate exists over what should be considered the best approach for teaching individuals with severe hearing impairments. Some advocate total communication (Owens, Metz, & Haas, 2003), which involves using speech (lip) reading, gestures, and sign language, or both oral and manual methods. Teachers using total communication rely on the structure of the English language, and speak while signing during communications with students who are deaf. Some advocate the use of only oral approaches, eliminating any manual components used in total communication. Teachers using only oral approaches rely heavily on parental and family involvement as well as auditory, visual, and tactile methods of presentation. Finally, others advocate using only sign language or manual approaches. These individuals advocate the exclusive use of sign language because they maintain that a unique “culture of the deaf” exists among those who communicate with sign language. They believe that when individuals with hearing impairments are taught only to speech read or use oral techniques, they are denied full participation in the culture of the deaf (Owens, Metz, & Haas, 2003; Reagan, 1990). Individuals from this position say they are not disabled, but that they are part of another cultural group composed of individuals who are deaf.
Several signing systems are in use today, including the American Sign Language (ASL), Fingerspelling, and Signing Exact English. All systems use manual signs made with the hands and fingers to represent words, concepts, and ideas. However, they are based on different systems. The American Sign Language (ASL) is a visual-spatial language, is not phonologically based like English, and is the official language of the culture of the deaf in the United States. ASL has its own rules of semantics, syntax, and pragmatics, and vocabulary (Owens, Metz, & Haas, 2003). Fingerspelling is a manual alphabet of 26 distinct hand positions used to represent each letter in the English alphabet. Fingerspelling is especially appropriate for unfamiliar words such as proper names. The following In the Classroom feature displays sample sign language positions and fingerspellings. Some teachers use Fingerspelling while speaking to students with hearing impairments. Signing Exact English is a system that employs components of ASL, but attempts to use correct English usage for facilitating the learning of reading and writing literacy skills in English for students who are deaf. No clear research evidence exists to promote one approach over the other in teaching students who are deaf. Therefore, it is likely that this debate will continue into the future.
Classroom Adaptations for Students with Hearing Impairments
Students with hearing impairments can benefit from instruction in general education classes if specific adaptations are made. Specific accommodations vary depending upon the degree of hearing impairment and whether students have interpreters to accompany them throughout the school day. If you have a student with hearing impairments in your class, establish classroom emergency procedures for use during fire and tornado drills. Many fire alarms can be equipped with a light that flashes while the bell rings, alerting students with hearing impairments. Consider assigning a peer assistant who can pass along information that comes from the announcement system and who can be a buddy during any emergency situations. In addition to these guidelines, consider the following strategies (see also Pakulski & Kaderavek, 2002; Stewart & Kluwin, 2001):
- Adapt the physical environment so students are seated close enough to the front of the class to maximize their hearing and enable them to read speech. They should also be able to turn to face other students while they are speaking. Because hearing aids are extra sound-sensitive, loud or irritating noises should be avoided. Consider choosing a room with carpeting and located away from noisy school areas, such as the cafeteria and gym.
- Use technology, including hearing aids, television captioning, adapted telephone equipment (TTY), computer-assisted instruction, and the Internet. When appropriate, use FM sound systems, which include cordless microphones for teachers, and receivers that attach to hearing aids for students. Pass your microphone to classmates who are speaking in a class discussion so they can also be heard.
- Use visuals such as illustrations, diagrams, pictures, and three-dimensional models to introduce vocabulary and concepts and enhance comprehension.
- Use language cards that contain vocabulary and illustrations of concepts and definitions that can accompany verbal presentations and be used to preteach. Encourage students to maintain personal dictionaries of their language cards.
- Create authentic experiences by connecting new language and knowledge to real-world experiences in a context relevant to the student’s linguistic and experiential background.
- Reiterate major points, write out assignments, or write down questions on overhead transparencies or the chalkboard. Give students outlines or closing summaries as handouts. Repeat questions or answers that other students contribute, to enable hearing impaired students to fully participate in class. Sequence steps or procedures on written cards and place them in clear view.
- Use hand signals or devise a signaling system to denote transitions or allow students with hearing impairments or interpreters to review questions, answers, and concepts.
- Alert students as to when to look or listen and position yourself so students with hearing impairments can clearly see your face, without shadowing from backlighting or the reflection of glaring light.
- Use a “listen, then look, then listen” sequence of instruction, so students can focus on your face as you speak, then focus on the other aspects of the lesson separately, then focus on your face again. Say, for example, “Now, I’m going to pour the oil in with this water” (listen); then pour the oil (look), then say, “I poured the oil into the water. Who can tell me what happened?” (listen).
- Repeat information from the school public address system to ensure students have understood the announcements.
- Plan for interpreters. Interpreters often assist students who are deaf, by translating lecture information, tutoring, and assisting special and regular education teachers (Salend & Longo, 1994). Extra space, including chairs or desks, may be required for interpreters to be near students with hearing impairments. Since interpreters are typically adults and taller than your students, check to see that all children have a clear view of important classroom information. Prepare your students for the interpreter and clearly explain the roles and functions the interpreter will have while in your classroom. Schedule time alone with the interpreter to discuss your typical classroom procedures, materials, and routines. Remember that an interpreter cannot proceed at the same pace as your verbal presentation, and you need to slow your rate of presentation accordingly.
- Work with family members. Parents and other family members have an important influence on students with hearing impairments, with respect to such activities as going out and interacting with people, joining sports and other recreational activities, and monitoring and assisting homework (Stewart & Kluwin, 2001). Work with family members to help them prioritize and encourage important activities.
Testing and evaluation modifications for students with hearing impairments might include providing individual testing times in separate rooms, and extending the time limit as necessary. Remember to allow sufficient time for interpreters during oral testing situations. Allow students to draw illustrations of concepts. Use performance-based testing measures and identification formats whenever possible.
© ______ 2007, Merrill, an imprint of Pearson Education Inc. Used by permission. All rights reserved. The reproduction, duplication, or distribution of this material by any means including but not limited to email and blogs is strictly prohibited without the explicit permission of the publisher.


If you call your doctor because of vomiting issues, there’s no way that he or she can diagnose the problem over the phone. However, your symptoms can suggest possible remedies, including whether you need to take a trip to the emergency room, says gastroenterologist Brian Kirsh, MD.
Cleveland Clinic is a non-profit academic medical center. Advertising on our site helps support our mission. We do not endorse non-Cleveland Clinic products or services. Policy
“There’s no way to determine the diagnosis,” he says. “I wish there was a better way to triage over the phone. There’s no way to look into a crystal ball and say, ‘This will get better in an hour.’ If we knew those things, we would be clairvoyant.”
How to treat vomiting at home
Vomiting is often a harmless symptom of an infection (stomach flu) or a mild case of food poisoning.
To treat it:
- Drink clear liquids.
- Avoid solid food until the vomiting ends.
- Get extra rest.
- Temporarily stop taking all oral medications, which may irritate the stomach and make vomiting worse.
However, if the vomiting continues, you may need to seek medical help. With extended bouts of vomiting, dehydration is a concern.
When to visit the Emergency Department
For the most part, patients with uncontrolled vomiting for more than four or five hours — meaning they can’t keep down even clear fluids — should go to the ER, especially young children or elderly adults. Doctors can give them intravenous fluids and possibly nausea medication to make them more comfortable, Dr. Kirsh says.
“The young and the old are more susceptible to becoming ill more quickly, in terms of dehydration,” he says. “Those are patients you’re going to think about directing to the emergency department earlier rather than later, as opposed to a healthy 45-year-old.”
There are several questions a doctor on call will ask (and patients can ask themselves) in determining what the cause might be, as well as the most prudent course of action, Dr. Kirsh says.
- Are you vomiting blood? In that case he instructs them to go immediately to the ER, “even if it’s just a little bit, because there’s no way to know if it’s a ‘tip of the iceberg’ phenomenon.”
- Are you also experiencing diarrhea, and what about bloody diarrhea? That makes an ER trip more likely and can sometimes indicate an outbreak of food poisoning, which typically lasts longer than 24 hours. “Salmonella, e coli, the Jack in the Box outbreaks and those sorts of things can be more serious and prolonged,” Dr. Kirsh says.
- Was it something you ate? There’s no way to know for certain, but if you have friends or family members you recently saw who are also ill “that lends itself to an infectious cause,” he says. “We all ate at a picnic, and I know three other people who are sick.”
- Can you keep down clear fluids? If not, “there’s no way to rehydrate without an IV,” Dr. Kirsh says.
- Do you have a fever? That makes doctors think it’s probably an infection, although certain illnesses such as Crohn’s disease can bring bouts of fever due to inflammatory reactions. Fevers are less likely to happen if the cause is acid reflux, ulcer disease or bowel obstruction, although not having a fever doesn’t change the calculation about going to the emergency room.
- Do you have other significant symptoms? Dr. Kirsh says other red flags include severe abdominal pain, lethargy and mental confusion (the latter two symptoms are easier to decipher over the phone if someone other than the patient calls). “Those are big red flags,” he says, “and they should come in.”
Use these questions to help you identify red flags — reasons to visit an ER for vomiting rather than riding it out. If you are ever in doubt, call your doctor.


Many myths carry sacred objects associated with them. These range from the sword that King Arthur pulled from the stone to the cross on which Christ was crucified. The people who tell and retell these myths often carry representations of these myths with them as relics.
Do any of you carry or wear relics that would indicate your personal mythologies? These might be shared myths, such as the sacred stories of a religion, or they might be more private. If you do, how did these items become important? How do you treat them differently than secular objects? How do they fit in your personal mythology?
Also complete the following as a team and include in the final assignment:
- Discuss any concept that a team member is having a difficult time understanding.
- Examine the importance and applicability of this week’s concepts to each team member and to society in general.
The completed Week 5 Collaborative Exercise should include all of the above and should be posted as either a new threaded message or as a Word Document.
The finalized Week 5 Collaborative Exercise should be posted here in the Collaborative Exercise in a new thread with a subject line that reads “Final Week 5 Activity”