For the past few years, students in my first semester calculus physics laboratory have explored kinematics (and also a little dynamics) by building and launching model rockets. Working in groups, the students build Estes Big Bertha or Baby Bertha rockets from kits. Then, we travel to a local park to launch the rockets. The rockets carry an Arduino-based payload that samples and records the rocket’s (approximately) vertical acceleration during the launch. This data is then analyzed back in the lab using kinematic equations of motion to estimate the rockets velocity and position during the launch.

Here is a picture of a rocket with its payload attached via a short string to the nose cone. The payload fits in a film canister (remember those), which is small enough to fit inside the rocket. The payload is only 20.7 g. In comparison, a standard Arduino Uno R3 is 26.6 g. All together, the payload, a Big Bertha rocket, and an Estes C6-5 engine is about 110 g. This is just under the recommended maximum lift-off mass for the C6-5 engine (113 g).

The payload is composed of an Arduino Pro Mini, a SparkFun LIS331 accelerometer breakout board, a SparkFun OpenLog data logger, a small 110 mAh LiPo Battery, and a switch to activate the device.

The payload is running an Arduino sketch that incorporates SparkFun code for the LIS331 accelerometer. The sketch can be downloaded using this link. Approximately 30 second after the payload is activated by the switch, the sketch starts sampling and logging timestamped (approximately) vertical acceleration data to a microSD card every 20-25 ms.

Here are some pictures from launch days at the park. Spending late afternoons in late September and early October outdoors launching rockets is the best. We utilized either Estes C6-5 or B6-4 engines. Here are links to C6-5 and B6-4 bulk engine packs that include ignitors and wadding.

The rocket is prepared for launch by installing an engine, an igniter, flame retardant wadding, and the parachute.

The nose cone is put in place after the payload is loaded. This happens after the rocket is put on the launch pad.

You can see the payload next to the nose cone in this close up of the rocket after its parachute deployed.

Data Analysis

The raw data stored on the microSD card after a launch is a time series of one-dimensional acceleration data. Students isolate and clean up the portion of the data set corresponding to the period of engine burn. The data is also scaled and shifted to convert from units of g’s to units of m/s². Assuming the initial velocity (v₀) and initial vertical position (y₀) are zero and using the following definitions for average acceleration and average velocity, the acceleration time series is numerically integrated to yield velocity and potion.

When students do this, they are utilizing relationships between the kinematic quantities and the trapezoidal rule to numerically integrate, and they are also gaining experience with a real world data set which is discrete and somewhat messy. This is much better in my opinion than learning the calculus-based connections between acceleration, velocity, and position using the contrived polynomial descriptions of time-varying kinematic quantities often encountered in text books.

Below is an example data set from the launch of a Big Bertha with a C6-5 engine.

Students can use this data to make estimates of the rocket’s velocity and height at engine cut-off. The slight decrease in acceleration and the slope of the velocity curve during the sustained burn phase of the launch is evidence of velocity-dependent drag.

Assuming the rocket’s mass is constant during the launch (its not, its a rocket), the acceleration can be used with Newton’s second law to find the net force on the rocket. Below is this estimated net force plus the launch weight plotted for the same data set above. In the absence of friction this is equal to the engine thrust. Also shown is the thrust curve for a C6-5 rocket measured using a Vernier force probe and a static ground-based test apparatus I made.

Notice that while there is good qualitative agreement between the two curves, there are notable differences. For one, the peak force is larger for the static thrust measurements. Why? Can the difference be attributed to drag? I doubt it. Also, the slight downward trend in the net force minus weight data is evidence that the drag increases as the velocity increases. The inset with the static thrust curve is a thrust curve for this engine provided by Estes. Notice that their peak thrust is larger than what we measured but the burn duration is shorter than what we measured.

Note that the total impulse of the engine can be calculated by numerically integrating the thrust curve. This can be compared to a value reported in the Estes documentation for this engine.

One More Thing

One interesting observation I made while reading student reports on this project this year is related to how students interpret “messy” data. Below are two quotes from two different student reports.

… we noticed a large dip in the beginning of the [acceleration] graph, then it started accelerating. This could be due to a malfunction in the device that was measuring our data or it could be that the rocket stopped burning fuel for a moment, then started burning again.

Due to the unreliability of [the] … raw data, the accelerometer actually appears to fluctuate causing two separate peaks in thrust.

Both of these statements show that students tend to think that “messy” data is due to some kind of malfunction instead of simply accepting that “messy” is part of reality.

The Otto Cycle and internal combustion engines.

The Diesel engine.

A split-system air-source heat pump.

Brownian Particle Simulation in 2D

A Simulated Time-Lapse Video of Brownian Particles in 2D

Select File > Print …
Click PDF > Save as PDF …
Specify Save Location and Click Save

Windows

Click the Office Button
Select Save As
Select PDF or XPS
Select Save Location and Save as Type > PDF and Click Publish

To turn on or off a Arduino digital pin, its mode is first set using pinMode() and then its state is set using digitalWrite(). For example, to turn on digital pin 5 for one second then turn if off for one second repeatedly, the following code could be used.

int myPin = 5;
void setup() {
   pinMode(myPin,OUTPUT);
}
void loop() {
   digitalWrite(myPin,HIGH);
   delay(1000);
   digitalWrite(myPin,LOW);
   delay(1000);
}

It is also possible to control the digital pins by accessing the port registers directly. For example, the following achieves the same result as the above code. It is explained below.

void setup() {
   DDRD = DDRD | B00100000; 
}
void loop() {
   PORTD = PORTD | B00100000;
   delay(1000);
   PORTD = PORTD & B11011111;
   delay(1000);
}

Each port has a one byte register defining the direction of the associated pins. This register is called DDRD for port D and DDRB for port B. From zero to seven, each bit in this register corresponds to the comparably numbered pin of that port. For example, the fifth bit of DDRD controls port pin D5 or Arduino digital pin 5. If this bit is set to zero, the pin is an input. If this bit is set to one, the pin is an output pin. Thus, the line of code in the setup function above sets Arduino digital pin 5 to an output pin using a bitwise or operator. Each port also has a one byte register defining the state of the associated pins. This register is called PORTD for port D and PORTB for port B. Just like the DDRx registers, each bit in these registers from zero to seven corresponds to the comparably numbered pin of that port. For example, the fifth bit of PORTD controls the state of pin D5 or Arduino digital pin 5. If this bit is set to zero, the pin is set to 0 V. If this bit is set to one, the pin is set to 5 V (on the Arduino Uno). Thus the lines of code in the loop function above first turns on Arduino digital pin 5 using a bitwise or and then turns this pin off using a bitwise and.

Controlling digital i/o pins at the register level is incredibly powerful. For example, you could turn all 8 pins of port D using a single line of code if you wanted to. However, with great power comes great responsibility. Manipulating registers can be tricky and may yield unexpected results. For example, buried in the ATmega328 data sheet is a warning that one can not change a pin from the high impedance input off state to the output on state in one step. You must first go to an intermediate state of output low or input high before going to output high.

The figure above incorrectly shows the stop bit as 0V (low). It should be 5V (high).

In order for two devices to communicate via a serial signal, both must be configured with the same baud rate or bits per second (bps) rate. This tells both machines the interval of time between individual bits so they can synchronize. The most common baud rate for Arduino is 9600. In fact, this is the default baud rate when a new serial monitor is opened from the Arduino IDE. Other baud rates are sometimes necessary. For example, communication with GPS modules often uses a baud rate of 4800.

The following sketch demonstrates serial communication between an Arduino Uno and a the serial monitor on a computer. When a character is sent to the Arduino from the serial monitor on a computer, the Arduino reads this byte and immediately will send it back. The Serial.begin(), Serial.available(), Serial.read(), Serial.print(), and Serial.write() commands are used to start serial communication, test to see if any bytes are available in the serial buffer, read in the next byte in the serial buffer, print a decimal number to the serial monitor, and print the ASCII character corresponding to this decimal number, respectively. The comments in the code should help you figure out what each component does.

// Program Name: Serial Echo

// note: serial bytes are read as ASCII 
// (American Standard Code for Information Interchange) 
// characters

byte myByte; // a variable to store a byte read from the serial 
// buffer

void setup() {
  Serial.begin(9600); // begin serial communications at 9600 bps
}

void loop() {
 if (Serial.available()>0) {
  while(Serial.available()>0){ // while bytes remain in the serial 
  // buffer
  myByte = Serial.read(); // read in the current byte
  // = is ASCII character 61
  // 0-9 are ASCII characters 48 to 57
  // - is ASCII character 45
  // + is ASCII character 43
  }
  Serial.print("ASCII Character Value of Byte Read: \n");
  Serial.write(myByte);
  Serial.print('\n');
  Serial.print("ASCII Decimal Value of Byte Read: \n");
  Serial.print(myByte); // prints ASCII character corresponding 
  // to myByte
  Serial.print('\n');
 }
}

One important concept to understand is that serial information is sent out of and read into the Arduino one byte at a time. Moreover, each byte that is read into memory corresponds to the decimal ASCII encoding for the ASCII character being received. So, if the character A is sent, the value stored in myByte would be 65 since this is the decimal code for the ASCII character A. For more on ASCII characters and serial communications see this post.

Since there are three colors, controlling a common-cathode RGB LED with an Arduino requires three digital output pins (and three current limiting resistors). You could turn these pins off and on one at a time using digitalWrite() commands. You could also use a byte (of which one bit controls each of the colors so five bits would be unused) and a bit-mask. See this post for more details. This would result in more compact code.

When lights of different colors are combined, new colors result. But unlike pigment mixing, which is subtractive color mixing, light mixing results in additive color mixing. Red and green makes yellow, red and blue makes magenta, and green and blue makes cyan. If red, green, and blue are simultaneously turned on, white light is produced. In order to obtain more fine grained control over the color produced by an RGB LED, you can use PWM and analogWrite() (see this post for more details).

This particular relay is a single pole, double throw (SPDT) switch. If you were controlling a switch like this with an Arduino you would hook an Arduino digital pin up to pin 2 (or pin 5) then hook pin 5 (or pin 2) up to ground. Then setting the Arduino digital pin high will throw the switch. The device being switched should be hooked up across pins 1 and 3. Notice that a SPDT switch connects pins 1 and 4 when no current is supplied across pins 2 and 5. A single pole, single throw (SPST) switch like the one shown below (also made by OMRON) lacks this alternative path. An SPST switch will be specified to be normally open (NO) or normally closed (NC). This particular relay is normally open.

int myPins[] = {2, 3, 4, 5, 6, 7, 8, 9};
int onPins = B11010010; 

void setup() {
   for (int ii = 0; ii <= 7; ii++) {
      pinMode(myPins[ii],OUTPUT);
      digitalWrite(myPins[ii],LOW);
   }
}

void loop() {
   for (int ii = 0; ii <= 7; ii++) {
      if (onPins & (B10000000 >> ii)) {
         digitalWrite(myPins[ii],HIGH);
      }
      else {
         digitalWrite(myPins[ii],LOW);
      }
   }
}

The B10000000 >> ii portion of the code uses a right bit shift operator to shift each bit in B10000000 exactly ii places to the right. For each rightward shift, the least significant bit falls off and the most significant bit is replaced by a zero. For example B10000000 >> 4 would yield B00001000.

The conditional part of the if statement uses the bitwise AND compare. Each bit of the byte contained by onPins is compared to the corresponding bit of the byte resulting after the bit shift operator (what is often referred to as the bitmask). If any of the bitwise compares evaluates true then the entire if statement evaluates true and the if statement code is executed. If none of the bitwise compares evaluate true then the if statement evaluates false and the code in the else statement is executed.

Note that the result of the bitmask is to turn on all of the pins corresponding to the 1s in onPins and turn off all the other pins.

I hope you found this quick tutorial helpful. Happy programming.

newNumber = orignialNumber*maxValueOnNewRange/maxValueOnOriginalRange

The following is the prototype Arduino sketch promised above.

int analogValue; // a place to hold the decimal value produced by 
// the ADC
float analogVolts; // a place to hold the analogValue mapped back 
// to voltage
byte analogPin = 5; // the analog pin connected to the analog 
// signal we wish to read (pin A5)

void setup() {
// nothing
}

void loop() {
analogValue = analogRead(analogPin);
analogVolts = (float)analogValue*5/1023; // must convert int to float 
// to perform floating point math
}

Let’s say you did an experiment to measure the spring constant of a spring. You systematically varied the force exerted on the spring (F) and measured the amount the spring stretched (s). Hooke’s law states the F=-ks (let’s ignore the negative sign since it only tells us that the direction of F is opposite the direction of s). Because linear regression aims to minimize the total squared error in the vertical direction, it assumes that all of the error is in the y-variable. Let’s assume that since you control the force used, there is no error in this quantity. That makes F the independent value and it should be plotted on the x-axis. Therefore, s is the dependent variable and should be plotted on the y-axis. Notice that the slope of the fit will be equal to 1/k and we expect the y-intercept to be zero. (As an aside, in physics we would rarely force the y-intercept to be zero in the fit even if we expect it to be zero because if the y-intercept is not zero, it may reveal a systematic error in our experiment.)

The images below and the following text summarize the mechanics of using LINEST in Excel. Since it is an array function, select 6 cells (2 columns, 3 rows). You can select up to 5 rows (10 cells) and get even more statistics, but we usually only need the first six. Hit the equal sign key to tell Excel you are about to enter a function. Type LINEST(, use the mouse to select your y-data, type a comma, use the mouse to select your x-data, type another comma, then type true twice separated by a comma and close the parentheses. DON’T HIT ENTER. Instead, hold down shift and control and then press enter. This is the way to execute an array function. The second image below shows the results of the function. From left to right, the first row displays the slope and y-intercept, the second row displays the standard error of the slope and y-intercept. The first element in the third row displays the correlation coefficient. I actually don’t know what the second element is. Look it up if you are interested. By the way, you might wonder what the true arguments do. The first true tells LINEST not to force the y-intercept to be zero and the second true tells LINEST to return additional regression stats besides just the slope and y-intercept.

% define the number of frames in your movie
numberOfFrames = 1200;
% use a loop to generate frames of the movie
for ii = 1:numberOfFrames
    % insert code to update data to be plotted
    % plot data
    figure(1); clf;
    plot(x,y);
    % insert code to format plot any way you want
    drawnow; % force the plot to be displayed
    M(ii) = getframe(1); % save figure 1 as an element of
    % a movie object called M
end

% use the movie2avi function to save the movie
% there are several parameters you can specify
% the only one usually worth messing with is 
% frames per second (fps)
% 20 fps will make this 1200 frame movie 60 s long
movie2avi(M, 'filename', 'fps', 20);

I hope this helps. The AVI will probably be over a GB in size. Use handbrake or ffmpeg to convert the movie made by MATLAB to a more compressed format like MP4.

R = ΔT/[(dQ/dt)/A]

where T is temperature, Q is heat, t is time, and A is surface area. The SI units for R are K m2 s/J or K m2/W however, most insulations sold in the US use the convoluted units of oF ft2 h/BTU.

The larger an insulations R-value, the better it is at slowing the flow of heat.

More insight into the meaning of R-value can be had by considering a different but equivalent definition. R-value is also the ratio of an insulations thickness over the thermal conductivity of the material from which it is made. More compactly,

R = L/k

where L is thickness and the thermal conductivity k has SI units of W/(K m) and Imperial units of BTU/(hr ft oF).

In this form, it can be seen that the thicker the insulation, the higher its R-value and the better it is at slowing the flow of heat. Two different insulations may have different R-values even if they are made out of the same material if they have different thicknesses. For this reason, R-value, like weight, is an extrinsic property of insulation. On the other hand, insulation’s thermal conductivity is an intrinsic property of the material from which it is made.

Since R-value depends only on thickness and thermal conductivity, it is additive if two or more pieces of insulation are combined. For example, if one were to sandwich two pieces of foam insulation with R-values of 5 and 8, respectively, the combination would have an R-value of 13.

The efficiency of a heat pump is highest when the difference between the indoor and outdoor temperature is the least. For this reason, air-source heat pumps are much more efficient in the spring and fall then in the winter and summer. The HSPF rating attempts to take seasonal variations in heat pump efficiency into account. For this reason, it can be thought of as an average heating efficiency over the course of a year.

HSPF is defined as the ratio of the thermal energy transferred into your home per heating season in British thermal units (BTU) divided by the electrical energy consumed by the heat pump in watt-hours (Wh) per heating season. More compactly,

HSPF = (thermal energy transfered, BTU)/(electrical energy used, Wh)

As a physicist, it doesn’t make much sense to mix two units of energy (BTU and Wh) in the same formula. It makes understanding the formula more complicated. If one notes that 1 Wh = 3.412 BTU, then

HSPF = 3.412 (thermal energy transfered)/(electrical energy used)

where the energies can be in any units so long as they are the same units. In this form, you can see that a 100% efficient electric resistive heater has a HSPF rating of 3.412. Thus a heat pump with a HSPF rating of 6.8 would pump about twice as much thermal energy into your home as it consumes in electricity.

Although the HSPF rating you will actual achieve depends on your climate (hotter climates will achieve higher real-life HSPF ratings than cooler climates) replacing a 6 HSPF heat pump with a 9 HSPF heat pump will decrease the amount of electricity needed to heat your home by about 33.3%. In general, you can calculate the percent reduction in electricity used by a new heat pump to heat your home using the following formula.

Percent Energy Savings = 1 - (Old System HSPF)/(New System HSPF)

The efficiency of a heat pump is highest when the difference between the indoor and outdoor temperature is the least. For this reason, air-source heat pumps are much more efficient in the spring and fall then in the winter and summer. The SEER rating attempts to take seasonal variations in heat pump efficiency into account. For this reason, it can be thought of as an average efficiency over the course of a year.

SEER is defined as the ratio of the thermal energy transfered out of your home per cooling season in British thermal units (BTU) divided by the electrical energy consumed by the heat pump in watt-hours (Wh) per cooling season. More compactly,

SEER = (thermal energy transfered, BTU)/(electrical energy used, Wh)

As a physicist, it doesn’t make much sense to mix two units of energy (BTU and Wh) in the same formula. It makes understanding the formula more complicated. If one notes that 1 Wh = 3.412 BTU, then

SEER = 3.412 (thermal energy transfered)/(electrical energy used)

where the energies can be in any units so long as they are the same units. In this form, you can see that a 100% efficient air conditioner has a SEER rating of 3.412. Thus a heat pump with a SEER rating of 6.8 would remove about twice as much thermal energy from your home as it consumes in electricity.

Although the SEER rating you will actual achieve depends on your climate (hotter climates will achieve lower real-life SEER ratings than cooler climates) replacing a 10 SEER heat pump with a 16 SEER heat pump will decrease the amount of electricity needed to cool your home by about 37.5%. Replacing a 10 SEER heat pump with a 22 SEER model will reduce the electricity used by your heat pump by about 54.5%. So there is diminishing returns to energy savings with increasing SEER rating. In general, you can calculate the percent reduction in electricity used by a new heat pump to cool your home using the following formula.

Percent Energy Savings = 1 - (Old System SEER)/(New System SEER)

Makeup of A Fictional Domain

Here we will consider the set up of a fictional domain named mydomain.lan on a restricted network (i.e., a LAN located behind a firewall) and the 192.168.1.0 subnet. The domain will have have 4 hosts with the following addresses, names, and roles.

IP Address          hostname     role                alias
192.168.1.99       john         DNS/mail server
192.168.1.50       paul         web server          www
192.168.1.51       george        workstation
192.168.1.52       ringo        workstation

Note that the web server is configured with the alias (canonical name) www so that one can navigate to it using www.mydomain.lan in addition to paul and paul.mydomain.lan. Of course your domain will vary in makeup and function to the one considered here, but you should be able to modify the following code to suit your needs.

Configure Zones on BIND

Ubuntu installs BIND with a configuration file /etc/bind/named.conf that suits most home office and small business needs and does not need to be modified. Instead you will create your local DNS “zone” by editing /etc/bind/named.conf.local, which is sourced by named.conf. Open this file with a text editor of your choice (I use vi here).

sudo vi /etc/bind/named.conf.local

Ignore the commented areas and add a zone definition for your domain to this file.

zone "mydomain.lan" IN {
    type master;
    file "/etc/bind/zones/mydomain.lan.db";
};

Add a reverse DNS zone definition as well. This will allow the server to map IP addresses to domain names.

zone "1.168.192.in-addr.arpa" {
    type master;
    file "/etc/bind/zones/rev.1.168.192.in-addr.arpa";
};

Create DNS Records

The zone definitions in the previous section refer to files that will contain details about our network mapping. The mydomain.lan.db file will contain records of the hostname-to-IP address mappings of your domain. The rev.1.168.192.in-addr.arpa file will contain “reverse” IP address-to-hostname records. Make a directory to hold these files and open mydomain.lan.db.

sudo mkdir /etc/bind/zones
sudo vi /etc/bind/zones/mydomain.lan.db

For the fictitious domain considered here mydomain.lan.db is edited to look like the following.

; Use semicolons to add comments.
; Host-to-IP Address DNS Pointers for mydomain.lan
; Note: The extra "." at the end of addresses are important.
; The following parameters set when DNS records will expire, etc.
; Importantly, the serial number must always be iterated upward to prevent
; undesirable consequences. A good format to use is YYYYMMDDI where
; the I index is in case you make more that one change in the same day.
mydomain.lan. IN SOA john.mydomain.lan. hostmaster.mydomain.lan. (
    200709131 ; serial
    8H ; refresh
    4H ; retry
    4W ; expire
    1D ; minimum
)
; NS indicates that john is the name server on mydomain.lan
; MX indicates that john is (also) the mail server on mydomain.lan
mydomain.lan.    IN NS  john.mydomain.lan.
mydomain.lan. IN MX 10 john.mydomain.lan.
; Set an alias (canonical name) for paul
www   IN  CNAME  paul.mydomain.lan.
; Set the address for localhost.mydomain.lan
localhost    IN A 127.0.0.1
; Set the hostnames in alphabetical order
george       IN A 192.168.1.51
john         IN A 192.168.1.99
paul         IN A 192.168.1.50
ringo        IN A 192.168.1.52

After creating the reverse DNS record file

sudo vi /etc/bind/zones/rev.1.168.192.in-addr.arpa

it is edited to look like the following.

; IP Address-to-Host DNS Pointers for 192.168.1.0 subnet
@ IN SOA  john.mydomain.lan. hostmaster.mydomain.lan. (
    200709131 ; serial
    8H ; refresh
    4H ; retry
    4W ; expire
    1D ; minimum
)
; define the authoritative name server
IN  NS   john.mydomain.lan.
; our hosts, in numeric order
99        IN PTR john.mydomain.lan.
50        IN PTR paul.mydomain.lan.
51        IN PTR george.mydomain.lan.
52        IN PTR ringo.mydomain.lan.

Of course, your DNS records will look different then those above but hopefully by using these configurations as templates you can customize the files to your domain. To initiate your authoritative DNS server restart BIND.

sudo /etc/init.d/bind9 restart

Test your DNS server by typing dig mydomain.lan at the command prompt. All of the hosts on your local network should appear under AUTHORITY SECTION in the output of this command.

Step 1: Install BIND DNS server on Ubuntu

There are two ways to install BIND on Ubuntu. If you are performing a fresh installation of Ubuntu Server Edition as per this post, at some point the install shell will ask if you wish to install a DNS and/or LAMP server. Select DNS (and LAMP if you so desire using the arrow keys and spacebar) and continue (using tab and enter). On the other hand, if you have already completed the installation of your LAMP server then use Ubuntu’s built in package management program apt-get to install BIND. Open a terminal and type

sudo apt-get update
sudo apt-get install bind9

You may need to insert the Ubuntu install CD to perform this installation.

Step 2: Configure BIND Caching DNS server

By default, BIND installs on Ubuntu configured to act as a caching DNS server. However, you need to edit the configuration options file /etc/bind/named.conf.options to specify a public DNS server operating on the wide area network (WAN) to which un-cached domain names should be forwarded. Open this file with the text editor of your choice (I use vi here).

sudo vi /etc/bind/named.conf.options

Uncomment and edit the forwarders section of this file to point to your internet service provider’s DNS server. You may enter multiple DNS server addresses (separated by semicolons) if you desire. When finished, the forwarders section should look like the following with the xxx.xxx.xxx.xxx replaced with the appropriate IP address(es).

forwarders {
xxx.xxx.xxx.xxx;
xxx.xxx.xxx.xxx;
};

You must also edit the /etc/resolv.conf configuration file of all machines on your LAN (including the DNS server itself) to point to your new DNS server. Open this file

vi /etc/resolv.conf

and add

nameserver xxx.xxx.xxx.xxx

to the top of the file where xxx.xxx.xxx.xxx is the IP address of your new DNS server. When configuring the DNS server itself, change the nameserver address to 127.0.0.1, which points to localhost. You may delete any additional nameserver lines appearing in the resolv.conf file although it may be prudent to leave lines in place that point to your ISP’s DNS server so that client machines continue to function in the event of your server going offline (just make sure your DNS server is listed first). To implement the changes to your DNS server, restart BIND.

sudo /etc/init.d/bind9 restart

Finally, test your server by typing the following command in a terminal on any machine on your LAN configured to use your new DNS server.

dig www.fiz-ix.com

Near the end of the output of this command there should be a line that reads Query time: 24 ms (of course the actual time may be different). Execute the dig www.fiz-ix.com command again and you should notice that the query time significantly decreased indicating that your DNS server is caching DNS information for www.fiz-ix.com. Note that BIND caches DNS information to RAM and not disk. In most cases this will not be a problem since most machines have plenty of memory and old records are purged from memory after a period of time. However, if you expect your server to get a lot of traffic you may want to periodically flush the cache using

sudo rndc -s localhost flush

or set the maximum amount of memory to use (in essence forcing overflow data to be deleted before it expires) by setting the max-cache-size option in the configuration file.

Congratulations! you are finished setting up your Ubuntu caching name server. See my next post where I discuss configuring a master DNS server to serve hostnames to machines on your LAN.