http://www.surpluscenter.com/New-Arrivals/1-96-STROKE-110-LB-12-VDC-LINEAR-ACTUATOR-5-1845-2.axd

SPECIFICATIONS Stroke 50 mm (1.96") Voltage 12 DC Push/Pull Rating Dynamic 110 lbs. max Extension Speed No Load 0.59 in/sec Max Load 0.39 in/sec Amps No Load 0.6 Full Load 3.4 Duty 20% Operational Temperature Range -14 F to +149 F Enclosure IP54 Pin Holes 1/4" Retracted Length 6-1/4" Shaft Dia. 20 mm (0.787") Size 6-7/8" x 1-11/16" x 3-1/4" Shpg. 5 lbs. 7/16"ID X 7/8" OD X 7/16" W Steel Zinc Solid Clamping Collar

http://www.cheniere.org/techpapers/on_extracting_EM%20energy.htm

www.phy6.org/Electric/-E17-ElectEnerg





http://img02.deviantart.net/a6a5/i/2012/211/f/f/raptor_skeleton_2_1_by_dotb18-d596lb7.jpg

 
Next Stop: E18.   Pumping Volts

Home Page "All Things Electric and Magnetic"
"From Stargazers to Starships"
Timeline of "All Things Electric and Magnetic"
Timeline (from "Stargazers")
Master index file

Author and Curator:   Dr. David P. Stern
    Mail to Dr.Stern:   stargaze("at" symbol)phy6.org .

Last updated: 12 July 2010


http://modifiedpowerwheels.com/

https://en.wikipedia.org/wiki/Gear_train










1.  #include <Wire.h>

2.  #include <Adafruit_PWMServoDriver.h>

3.   

4.  Adafruit_PWMServoDriver pwm1 = Adafruit_PWMServoDriver(0x40);

5.  Adafruit_PWMServoDriver pwm2 = Adafruit_PWMServoDriver(0x41);

6.   

7.  void setup() {

8.  Serial.begin(9600);

9.  Serial.println("16 channel PWM test!");

10.  

11. pwm1.begin();

12. pwm1.setPWMFreq(1600); // This is the maximum PWM frequency

13.  

14. pwm2.begin();

15. pwm2.setPWMFreq(1600); // This is the maximum PWM frequency

16. }

 


"Classic" Arduino wiring:

Older Mega wiring:

R3 and later Arduino wiring (Uno, Mega & Leonardo):
(These boards have dedicated SDA & SCL pins on the header nearest the USB connector)

 

http://www.sparkfun.com/commerce/product_info.php?products_id=8161

http://www.vti.fi/en/support/obsolete_products/pressure_sensors/

http://www.sparkfun.com/datasheets/Sensors/SCP1000-Testing.zip

http://www.sparkfun.com/commerce/categories.php?c=80

http://www.arduino.cc/en/Tutorial/ADXL3xx

Circuit:

SCP1000 sensor attached to pins 6,7, and 11 - 13:

DRDY: pin 6

CSB: pin 7

MOSI: pin 11

MISO: pin 12

SCK: pin 13

analog 0: accelerometer self test

analog 1: z-axis

analog 2: y-axis

analog 3: x-axis

analog 4: ground

analog 5: vcc

 

/*

DefaultServer

 

 

http://www.sparkfun.com/commerce/product_info.php?products_id=8161

http://www.vti.fi/en/support/obsolete_products/pressure_sensors/

http://www.sparkfun.com/datasheets/Sensors/SCP1000-Testing.zip

http://www.sparkfun.com/commerce/categories.php?c=80

http://www.arduino.cc/en/Tutorial/ADXL3xx

 

Circuit:

SCP1000 sensor attached to pins 6,7, and 11 - 13:

DRDY: pin 6

CSB: pin 7

MOSI: pin 11

MISO: pin 12

SCK: pin 13

analog 0: accelerometer self test

analog 1: z-axis

analog 2: y-axis

analog 3: x-axis

analog 4: ground

analog 5: vcc

 

*/

 

#include <Ethernet.h>

#include <SPI.h>

 

//CustomErrorCorrection

//SystemDiagnosticCodeHere

//FileRead

 

 

// assign a MAC address for the ethernet controller.

// fill in your address here:

byte mac[] = {

0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED

};

// assign an IP address for the controller:

IPAddress ip(192, 168, 1, 20);

IPAddress gateway(192, 168, 1, 1);

IPAddress subnet(255, 255, 255, 0);

 

 

// Initialize the Ethernet server library

// with the IP address and port you want to use

// (port 80 is default for HTTP):

EthernetServer server(80);

 

 

//Sensor's memory register addresses:

const int PRESSURE = 0x1F; //3 most significant bits of pressure

const int PRESSURE_LSB = 0x20; //16 least significant bits of pressure

const int TEMPERATURE = 0x21; //16 bit temperature reading

const int groundpin = 18; // analog input pin 4 -- ground

const int powerpin = 19; // analog input pin 5 -- voltage

const int xpin = A3; // x-axis of the accelerometer

const int ypin = A2; // y-axis

const int zpin = A1; // z-axis (only on 3-axis models)

 

// pins used for the connection with the sensor

// the others you need are controlled by the SPI library):

const int dataReadyPin = 6;

const int chipSelectPin = 7;

 

float temperature = 0.0;

long pressure = 0;

long lastReadingTime = 0;

 

void setup() {

// start the SPI library:

// initialize the serial communications:

Serial.begin(9600);

 

// Provide ground and power by using the analog inputs as normal

// digital pins. This makes it possible to directly connect the

// breakout board to the Arduino. If you use the normal 5V and

// GND pins on the Arduino, you can remove these lines.

pinMode(groundpin, OUTPUT);

pinMode(powerpin, OUTPUT);

digitalWrite(groundpin, LOW);

digitalWrite(powerpin, HIGH);

SPI.begin();

 

// start the Ethernet connection and the server:

Ethernet.begin(mac, ip);

server.begin();

 

// initalize the data ready and chip select pins:

pinMode(dataReadyPin, INPUT);

pinMode(chipSelectPin, OUTPUT);

 

Serial.begin(9600);

 

//Configure SCP1000 for low noise configuration:

writeRegister(0x02, 0x2D);

writeRegister(0x01, 0x03);

writeRegister(0x03, 0x02);

 

// give the sensor and Ethernet shield time to set up:

delay(1000);

 

//Set the sensor to high resolution mode tp start readings:

writeRegister(0x03, 0x0A);

 

}

 

void loop() {

 

//VariableUpdate

//DatabaseRecording

//SensorOutput

 

 

 

//ETHERNET START

 

// check for a reading no more than once a second.

if (millis() - lastReadingTime > 1000) {

// if there's a reading ready, read it:

// don't do anything until the data ready pin is high:

if (digitalRead(dataReadyPin) == HIGH) {

 

getData();

// timestamp the last time you got a reading:

lastReadingTime = millis();

}

}

 

// listen for incoming Ethernet connections:

listenForEthernetClients();

 

//ETHERNET START

}

 

 

void getData() {

 

// START HERE

 

// ADXL3xx START

// print the sensor values:

Serial.print(analogRead(xpin));

// print a tab between values:

Serial.print("\t");

Serial.print(analogRead(ypin));

// print a tab between values:

Serial.print("\t");

Serial.print(analogRead(zpin));

Serial.println();

// delay before next reading:

delay(100);

 

// ADXL3xx END

//Serial.println("Getting reading");

//Read the temperature data

//int tempData = readRegister(0x21, 2);

 

// convert the temperature to celsius and display it:

//temperature = (float)tempData / 20.0;

 

//Read the pressure data highest 3 bits:

//byte pressureDataHigh = readRegister(0x1F, 1);

//pressureDataHigh &= 0b00000111; //you only needs bits 2 to 0

 

//Read the pressure data lower 16 bits:

//unsigned int pressureDataLow = readRegister(0x20, 2);

//combine the two parts into one 19-bit number:

//pressure = ((pressureDataHigh << 16) | pressureDataLow) / 4;

 

//Serial.print("Temperature: ");

//Serial.print(temperature);

//Serial.println(" degrees C");

//Serial.print("Pressure: " + String(pressure));

//Serial.println(" Pa");

 

//SensorSweep

 

Serial.print("#");

 

// END HERE

}

 

void listenForEthernetClients() {

// listen for incoming clients

EthernetClient client = server.available();

if (client) {

Serial.println("Got a client");

// an http request ends with a blank line

boolean currentLineIsBlank = true;

while (client.connected()) {

if (client.available()) {

char c = client.read();

// if you've gotten to the end of the line (received a newline

// character) and the line is blank, the http request has ended,

// so you can send a reply

if (c == '\n' && currentLineIsBlank) {

// send a standard http response header

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println();

// print the current readings, in HTML format:

client.print("Temperature: ");

client.print(temperature);

client.print(" degrees C");

client.println("<br />");

client.print("Pressure: " + String(pressure));

client.print(" Pa");

client.println("<br />");

break;

}

if (c == '\n') {

// you're starting a new line

currentLineIsBlank = true;

}

else if (c != '\r') {

// you've gotten a character on the current line

currentLineIsBlank = false;

}

}

}

// give the web browser time to receive the data

delay(1);

// close the connection:

client.stop();

}

}

 

 

//Send a write command to SCP1000

void writeRegister(byte registerName, byte registerValue) {

// SCP1000 expects the register name in the upper 6 bits

// of the byte:

registerName <<= 2;

// command (read or write) goes in the lower two bits:

registerName |= 0b00000010; //Write command

 

// take the chip select low to select the device:

digitalWrite(chipSelectPin, LOW);

 

SPI.transfer(registerName); //Send register location

SPI.transfer(registerValue); //Send value to record into register

 

// take the chip select high to de-select:

digitalWrite(chipSelectPin, HIGH);

}

 

 

//Read register from the SCP1000:

unsigned int readRegister(byte registerName, int numBytes) {

byte inByte = 0; // incoming from the SPI read

unsigned int result = 0; // result to return

 

// SCP1000 expects the register name in the upper 6 bits

// of the byte:

registerName <<= 2;

// command (read or write) goes in the lower two bits:

registerName &= 0b11111100; //Read command

 

// take the chip select low to select the device:

digitalWrite(chipSelectPin, LOW);

// send the device the register you want to read:

int command = SPI.transfer(registerName);

// send a value of 0 to read the first byte returned:

inByte = SPI.transfer(0x00);

 

result = inByte;

// if there's more than one byte returned,

// shift the first byte then get the second byte:

if (numBytes > 1) {

result = inByte << 8;

inByte = SPI.transfer(0x00);

result = result | inByte;

}

// take the chip select high to de-select:

digitalWrite(chipSelectPin, HIGH);

// return the result:

return(result);

}

 

/* AnalogReadSerial Reads an analog input on pin 0, prints the result to the serial monitor. Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground. This example code is in the public domain. */ // the setup routine runs once when you press reset: void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); } // the loop routine runs over and over again forever: void loop() { // read the input on analog pin 0: int sensorValue = analogRead(A0); // print out the value you read: Serial.println(sensorValue); delay(1); // delay in between reads for stability }





MASTER TEMPLATE





Circuit: SCP1000 sensor attached to pins 6,7, and 11 - 13: DRDY: pin 6 CSB: pin 7 MOSI: pin 11 MISO: pin 12 SCK: pin 13 analog 0: accelerometer self test analog 1: z-axis analog 2: y-axis analog 3: x-axis analog 4: ground analog 5: vcc /* DefaultServer http://www.sparkfun.com/commerce/product_info.php?products_id=8161 http://www.vti.fi/en/support/obsolete_products/pressure_sensors/ http://www.sparkfun.com/datasheets/Sensors/SCP1000-Testing.zip http://www.sparkfun.com/commerce/categories.php?c=80 http://www.arduino.cc/en/Tutorial/ADXL3xx Circuit: SCP1000 sensor attached to pins 6,7, and 11 - 13: DRDY: pin 6 CSB: pin 7 MOSI: pin 11 MISO: pin 12 SCK: pin 13 analog 0: accelerometer self test analog 1: z-axis analog 2: y-axis analog 3: x-axis analog 4: ground analog 5: vcc */ #include #include #include #include //CustomErrorCorrection //SystemDiagnosticCodeHere //FileRead // assign a MAC address for the ethernet controller. // fill in your address here: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // assign an IP address for the controller: IPAddress ip(192, 168, 1, 20); IPAddress gateway(192, 168, 1, 1); IPAddress subnet(255, 255, 255, 0); // Initialize the Ethernet server library // with the IP address and port you want to use // (port 80 is default for HTTP): EthernetServer server(80); //Sensor's memory register addresses: const int PRESSURE = 0x1F; //3 most significant bits of pressure const int PRESSURE_LSB = 0x20; //16 least significant bits of pressure const int TEMPERATURE = 0x21; //16 bit temperature reading const int groundpin = 18; // analog input pin 4 -- ground const int powerpin = 19; // analog input pin 5 -- voltage const int xpin = A3; // x-axis of the accelerometer const int ypin = A2; // y-axis const int zpin = A1; // z-axis (only on 3-axis models) Adafruit_PWMServoDriver pwm1 = Adafruit_PWMServoDriver(0x40); Adafruit_PWMServoDriver pwm2 = Adafruit_PWMServoDriver(0x41); // pins used for the connection with the sensor // the others you need are controlled by the SPI library): const int dataReadyPin = 6; const int chipSelectPin = 7; float temperature = 0.0; long pressure = 0; long lastReadingTime = 0; void setup() { // start the SPI library: // initialize the serial communications: Serial.begin(9600); // Provide ground and power by using the analog inputs as normal // digital pins. This makes it possible to directly connect the // breakout board to the Arduino. If you use the normal 5V and // GND pins on the Arduino, you can remove these lines. pinMode(groundpin, OUTPUT); pinMode(powerpin, OUTPUT); digitalWrite(groundpin, LOW); digitalWrite(powerpin, HIGH); SPI.begin(); // start the Ethernet connection and the server: Ethernet.begin(mac, ip); server.begin(); // initalize the data ready and chip select pins: pinMode(dataReadyPin, INPUT); pinMode(chipSelectPin, OUTPUT); Serial.begin(9600); //Configure SCP1000 for low noise configuration: writeRegister(0x02, 0x2D); writeRegister(0x01, 0x03); writeRegister(0x03, 0x02); // give the sensor and Ethernet shield time to set up: delay(1000); //Set the sensor to high resolution mode tp start readings: writeRegister(0x03, 0x0A); Serial.begin(9600); Serial.println("16 channel PWM test!"); pwm1.begin(); pwm1.setPWMFreq(1600); // This is the maximum PWM frequency pwm2.begin(); pwm2.setPWMFreq(1600); // This is the maximum PWM frequency } void loop() { //VariableUpdate //DatabaseRecording //SensorOutput //ETHERNET START // check for a reading no more than once a second. if (millis() - lastReadingTime > 1000) { // if there's a reading ready, read it: // don't do anything until the data ready pin is high: if (digitalRead(dataReadyPin) == HIGH) { getData(); // timestamp the last time you got a reading: lastReadingTime = millis(); } } // listen for incoming Ethernet connections: listenForEthernetClients(); //ETHERNET START } void getData() { // START HERE // ADXL3xx START // print the sensor values: Serial.print(analogRead(xpin)); // print a tab between values: Serial.print("\t"); Serial.print(analogRead(ypin)); // print a tab between values: Serial.print("\t"); Serial.print(analogRead(zpin)); Serial.println(); // delay before next reading: delay(100); // ADXL3xx END //Serial.println("Getting reading"); //Read the temperature data //int tempData = readRegister(0x21, 2); // convert the temperature to celsius and display it: //temperature = (float)tempData / 20.0; //Read the pressure data highest 3 bits: //byte pressureDataHigh = readRegister(0x1F, 1); //pressureDataHigh &= 0b00000111; //you only needs bits 2 to 0 //Read the pressure data lower 16 bits: //unsigned int pressureDataLow = readRegister(0x20, 2); //combine the two parts into one 19-bit number: //pressure = ((pressureDataHigh << 16) | pressureDataLow) / 4; //Serial.print("Temperature: "); //Serial.print(temperature); //Serial.println(" degrees C"); //Serial.print("Pressure: " + String(pressure)); //Serial.println(" Pa"); //SensorSweep Serial.print("#"); // END HERE } void listenForEthernetClients() { // listen for incoming clients EthernetClient client = server.available(); if (client) { Serial.println("Got a client"); // an http request ends with a blank line boolean currentLineIsBlank = true; while (client.connected()) { if (client.available()) { char c = client.read(); // if you've gotten to the end of the line (received a newline // character) and the line is blank, the http request has ended, // so you can send a reply if (c == '\n' && currentLineIsBlank) { // send a standard http response header client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); // print the current readings, in HTML format: client.print("Temperature: "); client.print(temperature); client.print(" degrees C"); client.println("
"); client.print("Pressure: " + String(pressure)); client.print(" Pa"); client.println("
"); break; } if (c == '\n') { // you're starting a new line currentLineIsBlank = true; } else if (c != '\r') { // you've gotten a character on the current line currentLineIsBlank = false; } } } // give the web browser time to receive the data delay(1); // close the connection: client.stop(); } } //Send a write command to SCP1000 void writeRegister(byte registerName, byte registerValue) { // SCP1000 expects the register name in the upper 6 bits // of the byte: registerName <<= 2; // command (read or write) goes in the lower two bits: registerName |= 0b00000010; //Write command // take the chip select low to select the device: digitalWrite(chipSelectPin, LOW); SPI.transfer(registerName); //Send register location SPI.transfer(registerValue); //Send value to record into register // take the chip select high to de-select: digitalWrite(chipSelectPin, HIGH); } //Read register from the SCP1000: unsigned int readRegister(byte registerName, int numBytes) { byte inByte = 0; // incoming from the SPI read unsigned int result = 0; // result to return // SCP1000 expects the register name in the upper 6 bits // of the byte: registerName <<= 2; // command (read or write) goes in the lower two bits: registerName &= 0b11111100; //Read command // take the chip select low to select the device: digitalWrite(chipSelectPin, LOW); // send the device the register you want to read: int command = SPI.transfer(registerName); // send a value of 0 to read the first byte returned: inByte = SPI.transfer(0x00); result = inByte; // if there's more than one byte returned, // shift the first byte then get the second byte: if (numBytes > 1) { result = inByte << 8; inByte = SPI.transfer(0x00); result = result | inByte; } // take the chip select high to de-select: digitalWrite(chipSelectPin, HIGH); // return the result: return(result); }




 

(E17)   Capacitance and stored Electric Energy     

    As already noted, even large capacitors cannot store much electric charge. A 100-watt lightbulb draws about 0.9 amperes, i.e. a charge of 0.9 coulomb per second: a capacitor storing even 1% of this charge at 110 volts would have to be extremely large. Compare this to a car battery, whose specifications typically promise over 100 ampere-hours!

    Still, storage of charge implies the storage of electrical energy. A storage battery, in contrast, stores chemical energy, which can be converted to electrical if the need arises: it is not the same thing. A capacitor delivers all of its energy much more rapidly.

    The unit of capacitance is named farad, after Michael Faraday, whose work will be described in a later section. A capacitor of 1 Farad charged to 1 volt holds 1 coulomb--when charged to 20 volts, 20 coulombs, etc. You will not encounter capacitors that big: practical units are more likely to be rated in microfarads, millionths of a farad, or even picofarads, millionths of a microfarad.

    The word "micro" (Greek for "small") is usually used to denote "a millionth" of a quantity (just as "milli" means "a thousandth"). The word is commonly denoted by the Greek letter mu or μ (lower-case Greek m). A microfarad is then abbreviated μf, a picofarad pf or μμf. The DC power supply of an old-style radio receiver may have a 5-50 μf capacitor, while the circuitry itself may have component capacitors of 500 μμf or smaller. Radio frequency is quite high, so even a small capacitor is not much of an obstacle.

    As noted, a capacitance of C farad, charged to a voltage of V0 volts, contains a charge

Q = C V coulomb

    Suppose a capacitance C is charged to voltage V0: its charge is then

Q0 = C V0 coulomb

    How much energy does such a device store? Suppose we discharge it in one second. Then since amperes = coulombs/second, the average current over that second (averages denoted here by curly brackets) is then

{I} = Q0 amperes

    The average voltage is not V0, because as charge drains away, the voltage drops. Dividing both sides of the first equation above by C (and switching sides)

V = Q / C

    showing that as the charge drains away, starting with Q0 and ending with zero, the voltage also drops steadily, from V0 to zero (drawn graph)

    We may estimate (and a rigorous calculation confirms it) that the average voltage is half the peak value

{V} = V0/ 2

    The average power generated--current multiplied by voltage--is therefore

{W} = {I}{V} = Q0V0/2 watts

    Substituting Q from the top equation

{W} = C V02/2 watts

    The energy E = Wt is power multiplied by time. Since the discharge lasts one second, we get

E = C V02/2 joule
If the discharge time were N times longer, the same result is obtained: the average voltage is still V0/2, the current 1/N its value, but its longer duration cancels the factor N.

What is going on here?

    How can parallel plates insulated from each other hold much more charge? Essentially, the positive charge on one attracts the negative charge on the other, enabling it to hold more. If one plate is given (say) a negative charge and the other one is connected to the ground, equal and opposite (that is positive) charge will be drawn up to it from the ground. If later we disconnect the ground, that plate will remain positively charged.

    The insulator between the plates (the "dielectric material") also plays an important role. Its atoms too contain negative electrons and positive nuclei, though those charges cannot move freely, as they might do in a conductor. However, the electric forces (or "electric field") in the gap between the two plates cause the distribution of charges to deform--positive charges may shift slightly towards the negative charges outside, while negative charges back away a little.

    The electric deformation of atoms of the insulator shields the electric force inside the material, making it weaker there, and may enable the plates to hold several times more charge. Thus the capacitance of a capacitor is multiplied by the "dielectric constant" ε (Greek epsilon) of the insulating material between them. One material of exceptionally high dielectric constant ε=81 is water, which explains why it is able to loosen the bonds in ionic compounds, held together by electric attraction. That however only holds on the atomic scale, while water in a cup (even distilled water) is not an insulator but a conductor, because at least some of its molecules are constantly dissociating.

The Neon Flasher

    With the help of a capacitor a very simple flashing light may be constructed, based on the neon light, a small lightbulb filled with low-pressure neon gas. The light of a neon light, like that of a fluorescent light fixture, is produced by an electric current flowing across the gas-filled gap, carried by a plasma, a gas in which some electrons (at least) are detached from their atoms (which are left with positive charges). The voltage across the gap accelerates some electrons, which then can "ionize" some more atoms (separating electrons from them) and increase the current. Ultimately however they are recaptured, while other electrons are "bumped up to a higher energy level" of their atom. When they return to the lowest "ground level" of energy (in a fraction of a millionth of a second, usually), or are recaptured, they give up their extra energy as light.

    You should not be surprised that such conduction does not obey Ohm's law, according to which the current is proportional to the voltage across the gap. (Indeed, Ohm's law is not a fundamental law of nature--only an approximation to the behavior observed in many everyday electrical conductors). When the voltage is low--say below 70 volt--no appreciable current flows at all. Some ions may form spontaneously (from surrounding radioactivity and cosmic rays), but they recombine before the voltage accelerates them sufficiently to create more ions, and the current they carry across the gas is tiny.

    However, once a certain threshold value is passed--depends on the device, but 70 volt is typical--electrons are accelerated enough between collisions to free up additional electrons, and the whole process turns into an unstable "avalanche." The neon tube then becomes a "greedy conductor," drawing more and more electrons until some limit is passed--e.g. it gives one very bright flash and then stops working altogether. That can be prevented by placing a large resistance--say, 10 million ohms--in the circuit of the lightbulb, which limits the current to microamperes, still enough to produce visible light.

    Lamps with such resistance built-in and two insulated probe wires sticking out are sold as neon tube testers, to safely check whether a circuit is "live" (connected to the power) or "dead." You can stick both wires into an electric outlet and see if the lamp lights up, showing the outlet is "hot." To tell which of the sides of the outlet is hot and which one is grounded, stick one contact of the tested in the outlet and hold the other between two fingers, connecting it to the ground. If outlet connection leads to the "hot" side, the lamp will lights up; an electric current then flows through your fingers to the ground, but it is so small you will not notice it.

    A crude oscillating circuit can be made by connecting a capacitor in parallel with the lamp, one side branching off from each side of the lamp, and with a large resistor limiting the current (illustration; obtain the neon lamp separately--the one in the neon tester also has a big resistance built-in). The instant the circuit is connected to a source of DC voltage--say, 100 volts--a current will flow through the resistor to the branch-off points. Initially, the capacitor will grab it all and the light will not flash.

    Once the capacitor is charged to (say) 70 volts, the lamp flashes as charge begins to flow through it, a very short flash. Soon, however (say, when the capacitor voltage falls to 60 volts), the lamp goes out and the charging resumes. Thus the lamp will oscillate between 60 and 70 volts. The wave form is very similar to a sawtooth: when the discharge starts, a rapid "avalanche" of current quickly drains charge down to the cut-off (say, 60 v) and creates a flash of light. Then, however, the current stops while the capacitor charges back to the "ignition voltage" and the process repeats, again and again.

The important number here is the time constant T of the circuit

T = RC

If the resistance R is measured in ohms and C in farad (or else, R in megohms and C in microfarad), then T is in seconds. The actual duration of each oscillation depends also on the voltage supply and on the ignition and extinction voltages of the neon discharge. But in practice, it will be proportional to RC--say, 0.1 RC.

    Neon lights with big resistors are also attached to "power strips" combining outlets, or to other electric devices, to show if they are connected or not (running them takes very little energy). They tend to flicker, and you might notice the flickering is slower in a dark room--perhaps because electrons ejected by visible light help start the discharge.

    An electronic flash on a photographic camera also discharges a capacitor through a gas plasma--in this case, the preferred gas is xenon. The charge is generated by a small circuit powered by a dry cell, connected to a transformer: once the voltage needed for a discharge is reached, the charging stops, and the capacitor is then discharged when a switch in the camera is closed.