time trial using photosensor

Your program would be...

1. Set up a loop to detect when start pin goes low (as light gets blocked from CDs). This seems like a one line instruction such as ... If pin A1 = 0 then goto StartTiming else keep looping

2. Then you would have a timing loop at StartTiming.

While A2 is not 0 (blocked by object)
increment time counter by one microsecond
keep looping

3. Then you would just output the value of your timing counter.

Easy to do in MikroBasic or on the Arduino.

 

I wanted to try your project on my Arduino uno.

On the hardware side all I did was plug to insert two photoresistors (CdS), one with its leads into A0 and +5V and the other into A0 and ground. This is just a voltage divider circuit of two variable resistors connected between +5 and ground, with a tap from between them to analog port A0.

Here was the Arduino C program to drive it. It worked OK and outputs the time in milliseconds. To start timing, I covered the first sensor (eg ball rolling past sensor) and to stop timing I covered the second sensor (ball rolling past second "eye"). This program can be improved (eg it takes no account of thickness of ball or time C commands take to execute) but it is a start.

I checked the analog values the sensors gave first, and if one was covered it had values about 40 and if the other was covered it read 200.

Here was the program...



*/



// These constants won't change. They're used to give names

// to the pins used:

const int analogInPin = A0; // Analog input pin that the potentiometer is attached to



int sensorValue = 0; // value read from the pot

int outputValue = 0; // value output to the PWM (analog out)



void setup() {

// initialize serial communications at 9600 bps:

Serial.begin(9600);

}

int count = 0; //set up your timing counter

void loop() {

// read the analog in value:

sensorValue = analogRead(analogInPin);

// map it to the range of the analog out:

outputValue = map(sensorValue, 0, 1023, 0, 255);

if (outputValue <100) // you are covering the start semsor

{count = 0;} // start the time count

//{Serial.println(outputValue);}

if (outputValue >200) // you are covering the out sensor

{Serial.println(count);} // write the time in milliseconds to serial monitor

delay(10); // delay 10 microseconds

count = count + 10; // update the time counter by 10 microseconds

}

 

Yes, that is what you need.

Is this a genuine project, or just some kind of homework?
What exactly are you planning to time?

What I described above is just a general setup, but it would have to be tailored for the specific thing you have in mind.

 

Now I understand that this is a project for your studies - and they have set you the problem of determining the time it takes a bag to move between two points.

Since the problem itself could be solved by taking a stopwatch and timing the bag, I assume that the process itself is what is important, and that process involves using a simulation.

I have seen simulators for the PIC microprocessor but do not offhand know of one for the Arduino - though there must be. The uno uses the ATmega328 chip - for which there must be a simulator. I dont know how a simulator could simulate how the uno writes data to the com serial port of your pc.

These only simulate the programs code - they do not simulate the components attached to the microprocessor (which seems to be what fritzing focuses on).

I really dont know what more to suggest. In the past when doing PIC programming in assembler, the assembler simulator would show what all the registers were doing, when a button was pressed and the microprocessor pins became high or low. But unless you need assembler, writing in assembler is to be avoided.

Do they tell you which microprocessor to use and which language to write your code in? That would determine the simulator to use.

 

A vast majority of the current micro simulators also have simulations for external components, especially things like LCD displays, or at least let you see the serial output...

But, personally this is a simple project that I wouldn't even be bothered with simulation, I would just build a quick mock up and tweak it on real hardware...

 

On the Arduino uno the circuit was as simple as this, and worked fine as an analog input.


Ground------------CdS---------PinA0---------CdS---------+5V

In other words both photoresistors acted like a potential divider, with A0 in common with both, and the other legs of each photoresistor going to ground and +5V.