Distance, Velocity and Acceleration Detection

Transcription

1 Distance, Velocity and Acceleration Detection Andrew Walma and Scott Duong Abstract For this project we constructed a device that will measure the distance of an object using a high frequency transmitter and receiver. The transmitter will send out a sound pulse of high frequency when a button is pressed. The pulse is then reflected off of an object and the receiver will detect the incoming pulse and calculate the distance using the travel time of the sound pulse. It is known that the speed of sound is different depending on the air temperatures, therefore this has to be taken into consideration so the device has to be calibrated. This is done by sending one pulse at an object that is placed a known 1m away. The time it takes for this pulse to return to the receiver will be captured and stored as a calibration time. After a calibration time is stored the device can measure various object distances. It does this by capturing the travel time of a sound pulse and scaling it by a factor of This scaled distance is then divided by the calibration time, and the result of that operation yields the distance of the object with an extra factor of This is easily accounted for by turning on the appropriate decimal point on the LED displays when displaying the distance. The distance is then displayed on the LED display in meters. Introduction Ultrasonic ranging is a powerful tool that animals such as bats and dolphins rely on for survival in their natural habitats. The ability to detect objects by sending high frequency sound pulses allows bats to maneuver and detect prey in the darkness of night. This technique has been observed and mimicked by humans and the use of ultrasonic sound waves has been used in many useful applications. One of these applications is to detect distances which has a variety of uses ranging from mechanics labs to parking guides. For this reason the construction of an ultrasonic ranger is of great interest. Hardware To construct the range finder a Polaroid 6500 ranging module was used as a high frequency transmitter and receiver. This module had 9 pin outs, but only 5 were required to be connected to the PIC board. The pins required were ground, power, INIT, BINH, and ECHO. The INIT pin was connected to an output on the PIC board. When this output is set to high, the transponder sends out a sound pulse. The BINH pin is also connected to another output on the PIC. A high signal here tells the BINH to send a blanking signal after the INIT signal has been sent. This blanking signal is just used to prevent the high frequency waves from bouncing off of each other and causing false echoes. Lastly the ECHO pin is connected to an input on the PIC along with a pull up resistor to ensure the returning sound pulse is detected. These pin outs can be seen in Figure 1 below. Figure 1: Pin outs of the Polaroid 6500 Ranging Module Software

2 Although the concept of calculating the distance is relatively simple, actually implementing these simple multiplications and divisions in assembly language proved to be the most difficult part of this project. The reason being that values are stored in multiple registers, multiplication has to be implemented by continuous additions, and divisions require multiple subtractions all with counters which are also stored in multiple registers. Figure 2 is the flow chart which steps through the program and it shows the process that the device goes through to calculate distances. The fully documented code can also be seen in Appendix (I). Figure 2: Flow Chart of the Range Finder The most difficult part of the software was creating multiplication and division subprograms which is

3 required to calculate the distances. A multiplication is required to scale the travel time of the sound pulse when measuring distances. The reason for this scaling is to produce a higher precision of the device. A scaling of factor of 1000 was used so the calculated distance can display up to 3 decimal points. A scaling factor of 1000 means that the distance time would have to be added to itself 1000 times and stored in a separate registers. The process of scaling can be seen below in Figure 3. Figure 3: Flowchart for Scaling of the Distance Time Lastly to calculate the distance, the new scaled distance time would have to be divided by the calibration time. To perform a division, there is actually a series of subtractions that take place, with an up counter that increments every time the calibration time is successfully subtracted from the scaled distance time. The final counter value is actually the distance of the object. This multiple subtraction process is described in the Figure 4 flowchart. Figure 4: Flowchart for Performing Multiple Subtractions

4 The work log for this project can be seen in Appendix II Appendix I: The Code #UserISRon Refresh ;enables background scanning of LED display ; ;Variables cblock 0x20 KEYSAVE1 ;the button pressed in the startup menu KEYSAVE2 ;the button pressed in the calibration menu cltime ;low byte of calibration time signal chtime ;high byte of calibration time signal dltime ;low byte of distance time signal dhtime ;high byte of distance time signal dlreg ;least significant register of distance time signal after scaling dlmreg ;next significant '' dhmreg ;next significant '' dhreg ;most significant register of distance time signal after scaling dlsclf ;low byte of scaling factor dhsclf ;high byte of scaling factor ddivlc ;low byte of division counter (aka low byte of distance) ddivhc ;high byte of division counter (aka high byte of distance) endc ; clrf chtime ;ensure calibration time is zero clrf cltime movlw % ;initialize timer 1, and clearing its register's movwf T1CON bcf T1CON,0 clrf TMR1H clrf TMR1L startup clrw ;initializing starting screen. displays C2.D3. meaning calibrate by pressing button 2, and calc distance by pressing button 1 movlw % movwf Digit3 clrw movlw % movwf Digit2 clrw movlw % movwf Digit1 clrw movlw % movwf Digit0 goto sbutton ;goes to sbutton subroutine (checks for buttons being pressed) sbutton movlw 1 ;sbutton subroutine call Delay1s ;debouncing

5 call Getkey movwf KEYSAVE1 ;detects buttons being pressed bcf STATUS,C sublw 7 goto startup call scheck ;calls scheck to see which button is pressed movwf KEYSAVE1 movf KEYSAVE1,W sublw 2 ;if button 2 is pressed, then enter Calib subroutine where calibration occurs ;if 2 is pressed, 2-2 is zero and sets Z flag, therefore enter Calib goto Calib movf KEYSAVE1,W sublw 3 ;if 3 is pressed 3-3 is zero, hence setting Z flag, enters distance mode. goto Dist movf KEYSAVE1,W ;keys 4,5,6 never yeild a Z flag so returns to startup and waits for 2 or 3. sublw 4 goto startup movf KEYSAVE1,W sublw 5 goto startup movf KEYSAVE1,W sublw 6 goto startup scheck clrw ;checks for which key is pressed. movf KEYSAVE1,W andlw 7 bcf STATUS,C addwf PCL,F retlw 0 retlw 1 retlw 2 retlw 3 retlw 4 retlw 5 retlw 6 ; ;-Calibration tells the user to set up an object 1 m away. Once user is ready, press calibration button again (2) and device will send one sound pulse to bounce off the object and wait for its return ;-The time that it takes to return is recorded ;-It takes this time and stores it in two registers chtime (high register) and cltime (low register) ;-It then returns to the startup screen.

6 Calib clrf chtime ;clears calibration time registers clrf cltime clrf TMR1L ;clears timer registers clrf TMR1H clrw movlw % ;displays sd=1, meaning set distance equal to 1. movwf Digit3 clrw movlw % movwf Digit2 clrw movlw % movwf Digit1 clrw movlw % movwf Digit0 goto cbutton cbutton movlw 1 ;waits for calibration button (2) to be pressed again, all other keys disabled ;checks for which key in ccheck (calibration check) call Delay1s call Getkey movwf KEYSAVE2 bcf STATUS,C sublw 7 goto Calib call ccheck movwf KEYSAVE2 movf KEYSAVE2,W sublw 2 ;2-2 is zero setting the Z flag ;doesnt skip if Z is set goto Sound ;if 2 is pressed it goes to Sound subroutine where a pulse can be sent movf KEYSAVE2,W sublw 3 goto Calib ;all other buttons don't set Z flag so return to calibration screen movf KEYSAVE2,W sublw 4 goto Calib movf KEYSAVE2,W sublw 5 goto Calib movf KEYSAVE2,W sublw 6

7 goto Calib ccheck clrw movf KEYSAVE2,W andlw 7 bcf STATUS,C addwf PCL,F retlw 0 retlw 1 retlw 2 retlw 3 retlw 4 retlw 5 retlw 6 ;checks which key is pressed when waiting for calibration button to be pressed Sound clrf PORTD bsf PORTB,6 ;sends signal to INIT which is what tells the device to send a pulse bsf T1CON,0 ;turns on the the timer movlw 0x06 call Wait ;waits 0.9ms, this allows for a distance as small as 6inches from the device bsf PORTB,7 ;send blanking signal to prevent interference and reception of false echos goto crec ;goes to crec which checks for return of calibration signal crec btfss PORTE,0 ;test PORTE, 0 for return signal goto crec ;if no signal keep looking goto cstop ;if there is a signal go to cstop (calibration stop) cstop ;cstop turns the timer off and performs required delays bcf T1CON,0 ;stops the timer when signal is received movf TMR1L,W ;takes lower register of timer and stores in work register movwfcltime ;stores the timers low register into cltime (calibrated low time) movf TMR1H,W ;repeat for high register of the timer movwf chtime movlw 0xD8 call Wait call Wait call Wait ;above series of Waits causes a delay of 107ms bcf PORTB,6 ;then INIT is shut off movlw 0x06 call Wait ;wait 0.9ms bcf PORTB,7 ;shut off blanking signal movlw 0xD8 call Wait call Wait call Wait ;wait 107ms again, these delays are required by the device so signals are properly sent, INIT needs to be on for min of 100ms and off for a min of 100ms

8 goto startup ;returns to startup where the device is now calibrated ; ;Distance mode is where the distance of an object is calculated. This mode can only be entered when there is a calibration time stored in the calibration registers. ;When the distance button is pressed, a sound pulse is transmitted and the device waits for its return and records the time it takes for the signal to return. ;This time is in terms of clock pulses/ns, and is stored in dhtime (high register distance time) and dltime (low register distance time) ;To calculated distance this time needs to first be scaled (multiplied by 1000) or repeatedly added to itself 1000 times ;Once scaled and stored into the scaling registers (dlreg, dlmreg, dhmreg, dhreg). ;It is then divided by the calibration time (or the calibration time is subtracted repeatedly) where the result is the distance of the object with an extra factor of 1000 ;This extra factor is simply accounted for by turning on the proper decimal point on the LED displays when the distance is displayed ;The distance is then displayed for 3 seconds and then the device returns to the starting menu, where it can be recalibrated, or another distance can be measured using the previous calibration Dist movf cltime,w ;This is an error trap to prevents you from measuring a distance if the device is not calibrated sublw 0x01 ;The low register is the calibration time is moved into the work register and 1 is subtracted from it btfsc STATUS,C ;If there is a carry flag, that means that the subtraction is possible meaning there was a calibration time stored goto startup ;If there is no carry flag, there was no value in the calibration register meaning it was not calibrated and returns to the startup screen clrf dlreg ;clearing the registers of the scaling result (4 registers total) clrf dlmreg clrf dhmreg clrf dhreg clrf dhtime ;clearing the high register distance time clrf dltime ;clearing the low register distance time clrf TMR1L ;clearing the timer registers clrf TMR1H clrf PORTD ;clearing the display bsf PORTB,6 ;a signal is sent to INIT, which sends a sound pulse from the device bsf T1CON,0 ;the timer is turned on movlw 0x06 call Wait ;wait 0.9ms bsf PORTB,7 ;and sends blanking signal goto drec ;goes to drec, where the ECHO input is being monitored for the return signal drec btfss PORTE,0 ;checking for the return signal goto drec ;if there is no signal returned, keep looking goto dstop ;if there is a signal go to dstop where timers are turned off and the times are stored

9 dstop bcf T1CON,0 ;turns off the timer movf TMR1L,W ;takes the low timer register and stores it in dltime (distance low time) movwf dltime movf TMR1H,W ;takes the high timer register and stores it in dhtime (distance high time) movwf dhtime movlw 0xD8 ;delays are once again required for the proper function of the transponder call Wait call Wait call Wait ;wait 107ms because that is the minimum time that INIT has to be on for bcf PORTB,6 ;shut off init movlw 0x06 call Wait ;wait 0.9ms bcf PORTB,7 ;shut off blank movlw 0xD8 call Wait call Wait call Wait ;wait 100ms to ensure INIT is off for that period of time goto dcalc ;enter dcalc where the distance calculation process begins dcalc movlw 0xEB ;storing values into the two scaling factors registers to scale by 1000 movwf dlsclf movlw 0x03 movwf dhsclf goto scale ;go to scale to begin the multiplication by 1000, or addition 1000 times over scale movf dltime,w ;take the low register of the distance time and add it to the low register of the scaled result addwf dlreg btfss STATUS,C ;check if there is a carry flag goto adddlmr ;if there is no carry go to adddlmr (add distance lower middle register) adddlmr goto movlw 0x01 addwf dlmreg ;if there is a carry flag set, increment the the next highest register in the scaled result btfss STATUS,C ;checks for a carry flag goto adddlmr ;if there is no carry flag go to adddlmr to add to the lower middle register movlw 0x01 ;if there is a carry flag, increment the next highest register addwf dhmreg btfss STATUS,C ;check to see if that increment caused another carry flag goto adddlmr ;if there was no carry flag then go to adddlmr (add distance lower middle register) incf dhreg ;if there is a carry flag then increment the highest register then go to adddlmr adddlmr movf dhtime,w addwf dlmreg ;the high register of the distance time is then added to the next significant register of the scaled value dlmreg, (distance lower middle register)

10 btfss STATUS,C ;check to see if there is a carry flag after the addition goto sdec ;if there is no carry flag, go to sdec where the scaler value is decremented meaning one addition has been made movlw 0x01 ;if there is a carry flag set, increment the next significant scaled valued register, dhmreg, (distance higher middle register) addwf dhmreg btfss STATUS,C ;check the status of the dhmreg register after addition goto sdec ;if there is no carry flag then go to sdec to decrease the scaler count incf dhreg ;if there is a carry flag increment the last and highest scaled value register, dhreg, (distance highest register) goto sdec ;then go to sdec to decrease the scaler count sdec decf dlsclf btfss STATUS,Z goto scale decf dhsclf goto fadddff goto adddff adddff movlw 0xFF addwf dlsclf goto scale fadddff movlw 0xFF addwf dlsclf goto dfinish dfinish movf dltime,w addwf dlreg btfss STATUS,C goto fadddlmr incf dlmreg goto fadddlmr ;the lowest register of the scaling factor is decremented ;checks if the low register is zero ;if the low register of the scaling factor is not zero then go to scale and do another addition ;if the low register of the scaling factor is zero then decrement the higher register of the scaling factor ;check status of the zero flag on the higher register of the scaling factor ;if there is a zero flag set go to fadddff to to add 255 into lower scaler register then go into dfinish (decrement finish) ;if there is no zero flag set then go to adddff to add 255 into the lower scaler register (borrowing) and continue to scale ;when the zero flag in the high register of the scaling factor is not set, there are still values stored in there ;borrow 255 bits from the higher register by decrementing it and adding 255 to lower scaling factor register ;go to scale again to continue with more additions ;if there is a zero flag on the high scaling register that means, 255 needs to be borrowed from the high register ;since there is zero in the higher register, there are only 255 additions remaining before the value is considered scaled ;we then go to dfinish where addition continues but stops once the low register of the scaling factor hits zero ;adds the low register of the distance time to the lowest register of the scaled value ;checks if there is a carry set ;if there is no carry then go to fadddlmr, where the high bit of the distance time register is added to the dlmreg (distance lower middle register) of the scaled value ;if there is a carry then increment the next highest register then go to fadddlmr

11 fadddlmr movf dhtime,w ;the higher register of the distance time is added to the lower middle register of the scaled value addwf dlmreg btfss STATUS,C ;check for a carry flag set goto fsdec ;if there is no carry then go to fsdec where the last 255 additions in the lower scaling factor can be decremented movlw 0x01 ;if there is a carry flag then increment the high middle register of the scaled value addwf dhmreg btfss STATUS,C ;check if the high middle register has a carry flag set after the increment goto fsdec ;if there is no carry flag then go to fsdec incf dhreg ;if there is a carry flag then increment the highest register of the scaled value goto fsdec ;then go to fsdec fsdec decf dlsclf btfss STATUS,Z goto dfinish clrf ddivlc clrf ddivhc goto ddivide ;final scaling decrement, decrements the lower register of the scaling factor ;tests for a zero flag ;if there is no zero flag, then go to dfinish to perfrom another addition until the lower register of the scaling factor hits zero ;if there is a zero fag, means scaling is complete so clear the upcount registers used for division and go into ddivide where multiple subtractions occur ddivide movf cltime,w ;takes the low register of the calibration time subwf dlreg ;and subtracts from the lowest register of the scaled distance value btfss STATUS,C ;test for a carry (carry is set when a subtraction is possible, ie cltime < dlreg) call sublmr ;if there is no carry then must go to sublmr (subtract lower middle register) to borrow bits from next highest register of the scaled value btfss STATUS,C ;checks carry status of dlmreg to unsure that borrowing was possible call subhmr ;if there was no carry flag, it means could not borrow from dlmreg so go to subhmr to borrow from high middle register of the scaled value btfss STATUS,C ;checks for a carry flag to see if it was possible to borrow from dhmreg decf dhreg ;if there is no carry flag, could not borrow so we have to borrow from dhreg, highest register of the scaled value movf chtime,w ;if there is a carry flag it means it could borrow so continue to subtract the high register of the calibration time from the lower middle register of the scaled value subwf dlmreg btfss STATUS,C ;check to see if the subtraction was possible (chtime < dlmreg) call subhmr ;if no carry flag, means chtime > dlmreg so we have to borrow from next register, high middle register of scaled value btfss STATUS,C ;check to see if possible to borrow from dhmreg decf dhreg ;if could not borrow from dhmreg, then have to borrow from next register which is dhreg, highest register of the scaled value btfsc dhreg,7 ;the highest bit of the highest scaled value register is then tested

12 goto ddisp ;if the highest bit of the highest scaled value register isnt 0 then there is a negative number and subtraction is complete. Go to ddisp where the distance is displayed. movlw 0x01 ;if the highest bit of the highest scaled value register is zero then increment low register of the division count (one successful subtraction has taken place) addwf ddivlc btfsc STATUS,C ;test to see if there is a carry incf ddivhc ;if there is a carry then increment the high register of the division counter goto ddivide ;if there is no carry, go back up to divide and continue to subtract sublmr movlw 0x01 subwf dlmreg return subhmr movlw 0x01 subwf dhmreg return ;decrements dlmreg and returns to ddivide (borrowing from dlmreg) ;decrements dhmreg and returns to ddivide (borrowing from dhmreg) ddisp clrf PORTD ;clears the LED displays movf ddivhc,w ;the division counters is the distance of the object with an extra factor of 1000 movwf WH ;the high register of the division counter is placed into WH movf ddivlc,w movwf WL ;the low register of the division counter is placed into WL call Bin2BCD ;displays the distance of the object on the LED displays with an extra factor of 1000 call BCD2LED movlw % ;turns on the decimal point to account for the extra factor of Final displayed result is then in meters addwf Digit3 movlw 3 call Delay1s goto startup ;displays the distance for 3 seconds ;returns to the starting menu where the device can be recalibrated, or another distance can be taken.

13 Appendix II Date March 26/10 March 29/10 1/10 5/10 6/10 8/10 9/10 Progress Wrote rough pseudocode for calibration of device The idea was to transmit a sound pulse and record the time it takes for the source to return Since a distance of 1 m is set, using v=d/(t/2), the velocity of sound at the current temperature could be solved for and stored in memory to use to calculate other distances Began to program user interface Created startup screen displaying 4 different modes C.d.S.A which stands for calibration, distance, speed, acceleration, each letter represented a button on the pic to enter that corresponding mode Programmed it so that when button two was pressed pic would enter calibration loop. In this loop, made it display Sd=1 which tells the user to set up an object 1 meter away so that the device can be calibrated Wrote more pseudocode to calculate the distance of objects after the velocity of time was calculated The idea was to take the travel time of the sound pulse, divide it by 2, and multiple it with the speed of sound which is saved to yield the distance The distance would then be displayed Started to work with hardware. Got a Polaroid 6500 ranging module Determined the pinouts on the module Total of 9 pins, but only 5 would be needed: 0V, V+, ECHO, INIT, and BINH ECHO pin is the pin that detects the incoming sound pulse INIT pin sends a sound pulse BINH is a blanking signal which is sent after the INIT signal to prevent false echoes from things like the init signals interfering with each other Learned that the timing of the BINH signal is what determines how close the device can measure distances Started to set up the testing of the Polaroid 6500 Wrote a short bit of code to send pulses Connected pic to the ranger through a breadboard medium and used power from the breadboard Used an oscilloscope to monitor the INIT and ECHO pins Started to send pulses successfully and the signals could be seen on the scope Unable to receive signals at this point Continued to test the ranger Still sending but not receiving pulses Rearranged set up but yielded same results Continued to test ranger Installed a pull up resistor on the ECHO pin

14 12/10 13/10 16/10 22/10 Now successfully receiving signals Used the timing on the oscilloscope and successfully calculated distances by hand Started to run the ranger directly off the pic, but was not successful Perhaps a power issue at this point Returned to setup using breadboard The device could not receive signals anymore Tested all wires, the resistor and capacitor Decided to turn to software for a bit so looked into the pic timers Started reading about onboard timers particularity TIMER0 and TIMER 1 modules Deemed TIMER0 would not work because only 8 bits and could not store large enough times TIMER1 is a better option because 16 bits so larger distances with larger times could be measured Started to program the timers to see what they are capable of Wrote a program to ensure timers function Used the timer to time the count5ms to ensure there would be a time of 5ms saved in the timers Determined timers working Returned to hardware to see if signals could be received Decided to re-solder connections of the transponder Upon completion tested again using breadboard and once again successfully sending and receiving signals as seen on the oscilloscope Connected ranger directly to pic and ran off the pic s power while monitoring INIT and ECHO on the oscilloscope. Still successfully sending and receiving pulses Now that transponder is working like it is supposed to, cleaned up all hardware. Attached wires, pull up resistor, and capacitor to the pic Mounted the pic directly inside the box that holds the transponder with hot glue Hot glued the chip from the transponder with pinouts inside the box in a way that was easily accessible Made the necessary connections between the transponder pins and the pic Took the cover of the transponder to the machine shop and got the top cut off so the sides could be used to cover the side of the transponder box Screwed sides of the box on and completed hardware Tested to ensure signals could still be sent and received Wrote code to send a signal, and start timer and monitor input to detect the signal and turn off timer when signal has returned Sending and receiving signals from objects and various distances and successfully calculating the distance of the object by hand using the time stored from the timer This time is measured by total number of clock pulses, so to do this took the time stored in memory and multiplied it by 200ns (time of each pulse), divided by 2 (time travels the distance twice) and multiplied it with the approximate speed of sound in the room. This gave the distance of the object These multiplications and divisions proved to be very complex in terms of the

15 23/10 assembly language The original plan of taking the time captured and dividing it by the distance of 1m to get a velocity would not be as easy as it sounds Decided that it would be easier to first scale the times and work with ratios to calculate distances This would mean to scale times the time would have to be multiplied by 100 or 1000 depending on the precision desired The idea was to take the time it takes for the sound to travel 1m and add it to itself 100 times (scaled by 100) (calibration time) This value would then be stored and now when measuring object distances, the distance time would be saved and the calibration time would be divided by the distance time hence giving a distance Since the math was seemingly figured out, wrote a new program that would take a value and add it to itself 100 times Successfully wrote this scaling program and then incorporated it into the real program with the user interface Had to now find a way to divide the scaled calibration time by the distance time This would be a series of subtractions with an up counter. Wrote code to subtract using the compliment and addition but the thinking was all wrong Decided to scrap that way of subtracting Thought over the math being done to calculate distances but it didn t add up The distance time subtracted from the scaled calibration time did not yield the proper distance (did it by hand with a calculator) Had to rethink it and realized the distance time had to be scaled and the calibration time would be subtracted from the scaled distance time Tried to test this new method by capturing a some travel times but hardware was not working yet again It seemed like something was being grounded when it was not supposed to and the device would not reset properly The read key program previously written in labs seemed to just show up and would not allow the reset button to be pressed Unscrewed the side panels and disconnected the transponder to see if it was the issue but the pic would still not reset Pulled the pic from the hot glue holding it in place and saw some blobs of solder that may have been too close to other contacts Removed all large blobs on the pic and pic was functioning again The pic was placed back into the box and the connections were made with the transponder Hardware was now fixed and capture times could once again taken Used these capture times in the new method of calculating distances It worked out but since only scaling by 100, the precision was a little too low Rewrote the scaling program to scale by Extra registers were now required to store the scaled value which complicated things slightly

16 25/ /10 Eventually figured it out and incorporated the scaling by 1000 into the real program Had to also modify the program to scale the distance time, not the calibration time Started a new program to do multiple subtractions with an up counter Decided to subtract the low register of the calibration time from the lowest register of the scaled distance time and would check if borrowing from the next highest register was required If it was not required then it would subtract the next registers and once again check for carry flags This loop just continued with a counter that incremented every time one successful subtraction took place This counter would stop when the calibration time cannot be subtracted from the scaled distance time anymore Since the distance time was scaled the final result will also be scaled by 1000 This could be easily fixed by turning on the correct decimal point on the LED display Successfully programmed the subtraction and incorporated it into the main program Ran several tests and troubleshot and finally yielded accurate distances which were stored in memory Took this distance value and displayed it on the LEDs with the decimal point The device could now calibrate and detect distances successfully Due to time constraints decided that just measuring distances of objects is pretty good Decided to stop here and not perform velocity and acceleration measurements Reprogrammed the user interface to display c2.d3. on startup meaning calibrate with button 2 and measure distance with button 3 Programmed some error trapping Checked to make sure there was a calibration time stored, if there was no calibration time in the memory, no buttons except the calibration button would work Once there is a calibration time then the distance button will allow the user to send a pulse to detect the distance of an object. Also allowed recalibration so at any time the device can be calibrated again Disabled other buttons so the only two that work is button 2 for calibrating and button 3 for distance Went back and commented the code throughout Took rough log notes being taken throughout this process and typed up this log in full Created final presentation for submission Updated this log Completed project *Every part of this project was done together hence only one work log