user16949: My question is: how do I read multiple inputs at the same time without using interrupts on an UNO.  I'm building an RC drag strip with tree and finish line that will calculate run time as well as calculate each run in mph.  I'm using lasers and non modulated laser detectors for the beams and I'm using a 1" beam gap(between 1st beam and 2nd beam) at the finish line(for mph calculation). My concern comes in when two cars come close enough at the finish line for one to break the first beam at set the win flag but the car in the other lane is close enough to cross the 1st beam before the 1st car actually crosses the 2nd beam then the detection loop is going to miss one of them. (just a note: a few of these cars can top 100 mph when crossing the line) 

user2944: ONE:
What you can do is use a while loop waiting for the first pulse and then wait until the last pulse, for an idea look at this code from Gadjet, he made a chronograph with a similar operation, you would just need to adapt the design, this might not be as accurate for an 1". Also it will be the issue of having ties between cars. This is short as I don't like this option.
TWO:
Another option, although using what you don't want to use, would be using the interrupts on the Arduino. I am basing the following on the fact that you are using two cars.
What you can do is have a finish line for both vehicles and detect a break with a interrupt, one interrupt pin per lane(UNO has to interrupts).
The trick here is that you place both the outputs from one lane onto a single interrupt pin with a edge detector type of circuit1 to generate a pulse while the vehicle crosses a point, especially important as it will be in the inch area for a while. The code handles the double pulse on one pin. I know this works as I used this on a ballistic chronograph which works in microseconds detecting shots >2000fps over a 0.406 foot distance.
1 This is an example of the circuit you would use at the output of each sensor before the OR gates:

The hardware would just become a duplicate for each lane, and to combine the input on one pin you can use an OR gate IC or you can use diode OR gate:

Interrupts are actually easy to use with Arduinos, and there are a lot of examples out there.
Have a look at the below flow chart to get an idea of operation in the code:

A small thing would be that the code ignores a interrupt once the cars have passed so it doesn't calculate a second time.

user6628: Building upon Nick Gammon's excellent answer at How many interrupt pins can an Uno handle? here's some untested code:
 const int events = 256; // events to store
 unsigned volatile int index;  
 byte pinStates[events];
 unsigned int times[events];

 ISR (PCINT1_vect) //  Watch for pin changes on the C port (Uno pins A0-A5)
 {
   if (index == 0) { // start clock
    TCCR1B = bit(CS12) | bit (CS10) ;    // clock/1024 for <4.19s x 64us
    //TCCR1B = bit(CS12);                // clock/256  for <1.05s x 16us 
    //TCCR1B = bit(CS11) | bit (CS10) ;  // clock/64   for <0.25s x 4us
    //TCCR1B = bit(CS11) ;               // clock/8    for <0.03s x 0.5us
    //TCCR1B = bit(CS10) ;               // clock/1    for <0.004s x 62ns
   }
   times[index] = TCNT1;
   pinStates[index] = PORTC;
   index = (index+1) & 0xff; // increment and protect from overflow

 }  // end of PCINT1_vect

void setup ()
  { 
  // activate pin change interrupts on port C / pins A0-A5

  PCICR   =  bit (PCIE1);    // enable PCINT[14:8] pin triggers 
  PCMSK1 |=  bit (PCINT8) | 
             bit (PCINT9) | 
             bit (PCINT10) | 
             bit (PCINT11) | 
             bit (PCINT12) | 
             bit (PCINT13);     // enable individual pins

  // stop and clear 16 bit timer  CS1[0-2]=0; TCNT1 = 0;
  TCCR1A = 0;  // no comparisons, normal WGM mode, stop the counting 
  TCCR1B = 0;  
  TCNT1  = 0;  // Clear the counter

  pinMode (A0, INPUT_PULLUP);
  pinMode (A1, INPUT_PULLUP);
  pinMode (A2, INPUT_PULLUP);
  pinMode (A3, INPUT_PULLUP);
  pinMode (A4, INPUT_PULLUP);
  pinMode (A5, INPUT_PULLUP);

  index = 0 ; // nothing happened yet

  pinMode (5, OUTPUT);
  }  // end of setup

void loop ()
  {

   // check index, parse and report times, check for arming, etc...

  }

The point is to use the pin change interrupt to record state changes on the pins and the times.   The clock/1024 prescaler would give a 1/16MhZ*1024*65536= 4.19s window at 64us resolution timing counts, but you could go to higher resolution with a tighter window by using a smaller prescaler.
Also, if you wanted longer timing windows, you could cascade timer1 into timer0 (messing up millis(), etc.,) and get 24 bits of range before overflow, but a better way than cascading timers might be to add another interrupt to increment a variable.  For much longer timing windows add another quick interrupt to handle for timer1 overflow.  
...
volatile unsigned long int t1Cycles,times[events];
...

ISR(TIMER1_OVF_vect){t1Cycles++;}  

void setup(){
    ...
    TIMSK1 = bit(TOIE1);
    t1Cycles = 0;
    ...
} 

ISR (PCINT1_vect)
{
    ...
    times[index] = t1Cycles << 16 | TCNT1; // store 32 bit count of clocks
    ...
}

This is still untested, but it looks like it could be capable of 268 seconds worth of 62ns resolution multichannel timing.  With the longer period, you could move the conditional clock-starting code out of the pin-change ISR.

16949: <p>My question is: how do I read multiple inputs at the same time without using interrupts on an UNO.  I'm building an RC drag strip with tree and finish line that will calculate run time as well as calculate each run in mph.  I'm using lasers and non modulated laser detectors for the beams and I'm using a 1" beam gap(between 1st beam and 2nd beam) at the finish line(for mph calculation). My concern comes in when two cars come close enough at the finish line for one to break the first beam at set the win flag but the car in the other lane is close enough to cross the 1st beam before the 1st car actually crosses the 2nd beam then the detection loop is going to miss one of them. (just a note: a few of these cars can top 100 mph when crossing the line) </p>
 2944: <p><strong>ONE:</strong></p>

<p>What you can do is use a while loop waiting for the first pulse and then wait until the last pulse, for an idea look at <a href="https://dl.dropboxusercontent.com/u/2253850/Chronograph_7_Seg_on_Nano.ino" rel="nofollow noreferrer">this code from </a>Gadjet, he made a <a href="http://gadjetsblog.blogspot.co.za/2013/02/air-rifle-chronograph.html" rel="nofollow noreferrer">chronograph</a> with a similar operation, you would just need to adapt the design, this might not be as accurate for an 1". Also it will be the issue of having ties between cars. This is short as I don't like this option.</p>

<p><strong>TWO:</strong></p>

<p>Another option, although using what you don't want to use, would be using the interrupts on the Arduino. <em>I am basing the following on the fact that you are using two cars.</em></p>

<p>What you can do is have a <code>finish line</code> for <em>both vehicles</em> and detect a break with a interrupt, one interrupt pin per lane(UNO has to interrupts).</p>

<p>The trick here is that you place both the outputs from one lane onto a single interrupt pin with a edge detector type of <a href="https://electronics.stackexchange.com/questions/158015/how-to-turn-continuous-signal-into-a-short-pulse-using-logic-gates">circuit</a><sup>1</sup> to generate a pulse while the vehicle crosses a point, especially important as it will be in the inch area for a while. The code handles the double pulse on one pin. I know this works as I used this on a ballistic chronograph which works in microseconds detecting shots >2000fps over a 0.406 foot distance.</p>

<p><sup>1</sup> This is an example of the circuit you would use at the output of each sensor before the OR gates:
<a href="https://i.stack.imgur.com/eXQMP.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/eXQMP.png" alt="enter image description here"></a></p>

<p>The hardware would just become a duplicate for each lane, and to combine the input on one pin you can use an <a href="http://www.digikey.com/product-search/en/integrated-circuits-ics/logic-gates-and-inverters/2556317" rel="nofollow noreferrer">OR gate IC</a> or you can use diode OR gate:
<img src="https://i.stack.imgur.com/ntAAj.gif" alt="from ee.se"></p>

<p>Interrupts are actually easy to use with Arduinos, and there are <a href="https://www.google.com/search?q=arduino%20interrupts&amp;spell=1&amp;sa=X&amp;ved=0ahUKEwjg9LD2m9vKAhXFRhQKHTY7A1oQvwUIGigA" rel="nofollow noreferrer">a lot of examples</a> out there.</p>

<p>Have a look at the below flow chart to get an idea of operation in the code:</p>

<p><a href="https://i.stack.imgur.com/88Q1C.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/88Q1C.png" alt="RSM code"></a></p>

<p>A small thing would be that the code ignores a interrupt once the cars have passed so it doesn't calculate a second time.</p>
 6628: <p>Building upon Nick Gammon's excellent answer at <a href="https://arduino.stackexchange.com/questions/1784/how-many-interrupt-pins-can-an-uno-handle/12958#12958">How many interrupt pins can an Uno handle?</a> here's some untested code:</p>

<pre><code> const int events = 256; // events to store
 unsigned volatile int index;  
 byte pinStates[events];
 unsigned int times[events];

 ISR (PCINT1_vect) //  Watch for pin changes on the C port (Uno pins A0-A5)
 {
   if (index == 0) { // start clock
    TCCR1B = bit(CS12) | bit (CS10) ;    // clock/1024 for &lt;4.19s x 64us
    //TCCR1B = bit(CS12);                // clock/256  for &lt;1.05s x 16us 
    //TCCR1B = bit(CS11) | bit (CS10) ;  // clock/64   for &lt;0.25s x 4us
    //TCCR1B = bit(CS11) ;               // clock/8    for &lt;0.03s x 0.5us
    //TCCR1B = bit(CS10) ;               // clock/1    for &lt;0.004s x 62ns
   }
   times[index] = TCNT1;
   pinStates[index] = PORTC;
   index = (index+1) &amp; 0xff; // increment and protect from overflow

 }  // end of PCINT1_vect

void setup ()
  { 
  // activate pin change interrupts on port C / pins A0-A5

  PCICR   =  bit (PCIE1);    // enable PCINT[14:8] pin triggers 
  PCMSK1 |=  bit (PCINT8) | 
             bit (PCINT9) | 
             bit (PCINT10) | 
             bit (PCINT11) | 
             bit (PCINT12) | 
             bit (PCINT13);     // enable individual pins

  // stop and clear 16 bit timer  CS1[0-2]=0; TCNT1 = 0;
  TCCR1A = 0;  // no comparisons, normal WGM mode, stop the counting 
  TCCR1B = 0;  
  TCNT1  = 0;  // Clear the counter

  pinMode (A0, INPUT_PULLUP);
  pinMode (A1, INPUT_PULLUP);
  pinMode (A2, INPUT_PULLUP);
  pinMode (A3, INPUT_PULLUP);
  pinMode (A4, INPUT_PULLUP);
  pinMode (A5, INPUT_PULLUP);

  index = 0 ; // nothing happened yet

  pinMode (5, OUTPUT);
  }  // end of setup

void loop ()
  {

   // check index, parse and report times, check for arming, etc...

  }
</code></pre>

<p>The point is to use the pin change interrupt to record state changes on the pins and the times.   The clock/1024 prescaler would give a 1/16MhZ*1024*65536= 4.19s window at 64us resolution timing counts, but you could go to higher resolution with a tighter window by using a smaller prescaler.</p>

<p>Also, if you wanted longer timing windows, you could cascade timer1 into timer0 (messing up millis(), etc.,) and get 24 bits of range before overflow, but a better way than cascading timers might be to add another interrupt to increment a variable.  For much longer timing windows add another quick interrupt to handle for timer1 overflow.  </p>

<pre><code>...
volatile unsigned long int t1Cycles,times[events];
...

ISR(TIMER1_OVF_vect){t1Cycles++;}  

void setup(){
    ...
    TIMSK1 = bit(TOIE1);
    t1Cycles = 0;
    ...
} 

ISR (PCINT1_vect)
{
    ...
    times[index] = t1Cycles &lt;&lt; 16 | TCNT1; // store 32 bit count of clocks
    ...
}
</code></pre>

<p>This is still untested, but it looks like it could be capable of 268 seconds worth of 62ns resolution multichannel timing.  With the longer period, you could move the conditional clock-starting code out of the pin-change ISR.</p>
