Commits

jorodeo committed 583f36e

Added lcd_photogate_v2 directory.

  • Participants
  • Parent commits 180ea00

Comments (0)

Files changed (10)

+syntax: glob
+*.pyc
+*~
+*.o
+*.egg-info
+*.swp
+*.scad
+*.stl
+*.pkl
+*.dxf
+*.komodo*
+*.egg-info
+.DS_Store
+build
+dist
+.komodo*

File lcd_photogate_v2/DisplayHandler.cpp

+#include "util/atomic.h"
+#include "DisplayHandler.h"
+
+DisplayHandler::DisplayHandler(Print &port) {
+    _lcd.setPort(port); 
+    for (int i=1; i<DISPLAY_TRACE_BUF_LEN; i++) {
+        _traceBuf[i] = 0;
+    }
+    _tracePlotPos = 0;
+    _traceClearPos = DISPLAY_CLEAR_OFFSET;
+}
+
+void DisplayHandler::init() {
+    _lcd.clearScreen();
+    setBrightness();
+}
+
+void DisplayHandler::setBrightness() {
+    // Read Potentiometer value and use value to set brightness
+    // of LCD.
+    int pot;
+    int brightness;
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+        pot = analogRead(DISPLAY_POT_AIN);
+    }
+    brightness = map(pot,0,1024,0,100);
+    _lcd.setBrightness(brightness);
+}
+
+void DisplayHandler::showSplashScreen() {
+    // Draw Splash Screen w/ IO Rodeo logo.
+    _lcd.drawBox(1,1,127,63,1);
+    _lcd.print("PENDULUM EXPERIMENT",8,18);
+    _lcd.print("IO RODEO INC.",28,28);
+    delay(DISPLAY_SPLASH_TIMEOUT);
+    _lcd.clearScreen();
+}
+
+void DisplayHandler::updatePeriodText(uint16_t period) {
+    // Update period text on lcd display.
+    char msg[20];
+    int sec;
+    int frac;
+    if (period == 0) {
+        // We don't have a valid period measurement, display empty values
+        sprintf(msg,"PERIOD: _.___ S  ");
+        _lcd.print(msg,2,3);
+    }
+    else {
+        // Get seconds and fractional seconds
+        sec = period/1000;
+        frac = period - sec*1000;
+        sprintf(msg,"PERIOD: %d.%03d S  ",sec,frac);
+        _lcd.print(msg,2,3);
+    }
+}
+
+void DisplayHandler::updateTracePlot(uint16_t value) {
+    // Update the streaming plot trace.
+    uint16_t displayValue;
+    static uint16_t displayValueLast=0;
+
+    // Adjust value for display
+    displayValue = 55 - map(value,0,1024,0,35);
+
+    if ((displayValue > 55) || (displayValue < 20)) {
+        displayValue = displayValueLast;
+    }
+    
+    // Clear old trace values
+    if (_traceClearPos == 0) {
+        _lcd.setPixel(_traceClearPos,_traceBuf[_traceClearPos],0);
+    }
+    else {
+        _lcd.drawLine(
+                _traceClearPos-1,
+                _traceBuf[_traceClearPos-1],
+                _traceClearPos,
+                _traceBuf[_traceClearPos],
+                0
+                );
+    }
+    // Clear artifacts  - not sure what causes these
+    _lcd.drawLine(_traceClearPos, 19, _traceClearPos, 56, 0); 
+
+    // Plot new trace values.
+    if (_tracePlotPos == 0) {
+        _lcd.setPixel(_tracePlotPos,displayValue,1);
+    }
+    else {
+        _lcd.drawLine(
+                _tracePlotPos-1,
+                displayValueLast,
+                _tracePlotPos,
+                displayValue,
+                1
+                );
+    }
+
+    // Save last value and add data to trace buffer.
+    displayValueLast = displayValue;
+    _traceBuf[_tracePlotPos] = displayValue;
+
+    // Update trace plot position 
+    _tracePlotPos += 1;
+    if (_tracePlotPos > 127) {
+        _tracePlotPos = 0;
+    }
+
+    // Update trace clear position
+    _traceClearPos += 1;
+    if (_traceClearPos > 127) {
+        _traceClearPos = 0;
+    }
+}

File lcd_photogate_v2/DisplayHandler.h

+#ifndef _DISPLAY_HANDLER_H_
+#define _DISPLAY_HANDLER_H_
+#include "WProgram.h"
+#include "SerialLCD.h"
+
+#define DISPLAY_POT_AIN A4
+#define DISPLAY_SPLASH_TIMEOUT 2000 
+#define DISPLAY_TRACE_BUF_LEN 128
+#define DISPLAY_CLEAR_OFFSET 15
+
+class DisplayHandler {
+    private:
+        SerialLCD _lcd;
+        uint8_t _tracePlotPos;
+        uint8_t _traceClearPos;
+        uint16_t _traceBuf[DISPLAY_TRACE_BUF_LEN];
+    public:
+        DisplayHandler(Print &port);
+        void init();
+        void setBrightness();
+        void showSplashScreen();
+        void updatePeriodText(uint16_t period);
+        void updateTracePlot(uint16_t value);
+};
+
+#endif

File lcd_photogate_v2/LICENSE.txt

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+

File lcd_photogate_v2/Sensor.cpp

+#include "Sensor.h"
+
+Sensor::Sensor() {
+    _state = HIGH;
+    _currValue = 1024;
+    _prevValue = 1024;
+    _eventIntCntr = 0;
+    _timeOutFlag = true;
+    _numEvents = 0;
+    _valueBufPos = 0;
+    pinMode(SENSOR_LED_PIN,OUTPUT);
+    digitalWrite(SENSOR_LED_PIN,LOW);
+    for (int i=0; i<SENSOR_BUF_SZ; i++) {
+        _valueBuf[i] = 1024;
+    }
+}
+
+void Sensor::update() {
+    int val; 
+    val = analogRead(SENSOR_AIN);
+
+    // Increment event interval counter and check for timeout
+    _eventIntCntr++;
+    if (_eventIntCntr > SENSOR_TIMEOUT_CNT) {
+        _numEvents = 0;
+        _timeOutFlag = true;
+    }
+
+    if (_state == HIGH) {
+        if (val < (SENSOR_THRESHOLD - SENSOR_HYSTERESIS)) {
+            high2lowEvent();
+        }
+    }
+    else {
+        if (val > (SENSOR_THRESHOLD + SENSOR_HYSTERESIS)) {
+            low2highEvent();
+        }
+    }
+    _prevValue = _currValue;
+    _currValue = val;
+    updateValueBuf(val);
+}
+
+void Sensor::high2lowEvent() {
+    // Handle high-to-low transition event
+    _state = LOW;
+    digitalWrite(SENSOR_LED_PIN,HIGH);
+    if (_timeOutFlag == false) {
+        // Record high to low transition event
+        if (_numEvents < 3) {
+            _eventBuf[_numEvents] = _eventIntCntr;
+        }
+        else {
+            _eventBuf[0] = _eventBuf[1];
+            _eventBuf[1] = _eventBuf[2];
+            _eventBuf[2] = _eventIntCntr;
+        }
+        _numEvents++;
+        if (_numEvents > 3) {
+            _numEvents == 3;
+        }
+    }
+    // Resent event interval counter and time out flag.
+    _eventIntCntr = 0;
+    _timeOutFlag = false;
+}
+
+void Sensor::low2highEvent() {
+    // Handle low-to-high transition event
+    _state = HIGH;
+    digitalWrite(SENSOR_LED_PIN,LOW);
+}
+
+uint16_t Sensor::getCurrValue() {
+    // Return the current sensor value.
+    return _currValue;
+}
+
+uint16_t Sensor::getPrevValue() {
+    // Return the previous sensor value.
+    return _prevValue;
+}
+
+uint16_t Sensor::getPeriod() {
+    // Calculate the period of the pendulum using every other high-to-low
+    // transision.
+    uint16_t period;
+    if (_numEvents < 3) {
+        period = 0;
+    }
+    else {
+        period = _eventBuf[2] + _eventBuf[1];
+    }
+    return period;
+}
+
+void Sensor::updateValueBuf(uint16_t value) {
+    _valueBuf[_valueBufPos] = value;
+    _valueBufPos++;
+    if (_valueBufPos >= SENSOR_BUF_SZ) {
+        _valueBufPos = 0;
+    }
+}
+
+
+uint16_t Sensor::getMinValueInBuf() {
+    uint16_t value;
+    uint16_t minValue = 1024;
+    for (int i=0; i<SENSOR_BUF_SZ; i++) {
+        value = _valueBuf[i];
+        if (value < minValue) {
+            minValue = value;
+        }
+    }
+    return minValue;
+}

File lcd_photogate_v2/Sensor.h

+#ifndef _SENSOR_H_
+#define _SENSOR_H_
+#include "WProgram.h"
+
+#define SENSOR_AIN A0
+#define SENSOR_THRESHOLD 500
+#define SENSOR_HYSTERESIS 20
+#define SENSOR_LED_PIN 10
+#define SENSOR_TIMEOUT_CNT 2000
+#define SENSOR_BUF_SZ 20
+
+class Sensor {
+    private:
+        uint8_t _state;
+        uint16_t _currValue;
+        uint16_t _prevValue;
+        uint16_t _eventIntCntr;
+        uint8_t _numEvents;
+        uint16_t _eventBuf[3];
+        uint16_t _valueBuf[SENSOR_BUF_SZ];
+        uint16_t _valueBufPos;
+        bool _timeOutFlag;  
+        void high2lowEvent();
+        void low2highEvent();
+        void updateValueBuf(uint16_t value);
+        
+    public:
+        Sensor();
+        void update();
+        uint8_t getState();
+        uint16_t getCurrValue();
+        uint16_t getPrevValue();
+        uint16_t getPeriod();
+        uint16_t getMinValueInBuf();
+};
+#endif

File lcd_photogate_v2/SerialLCD.cpp

+#include "SerialLCD.h"
+
+SerialLCD::SerialLCD() {
+}
+
+SerialLCD::SerialLCD(Print &port) {
+    setPort(port);
+}
+
+void SerialLCD::setPort(Print &port) {
+    _portPtr = &port;
+}
+
+void SerialLCD::clearScreen(void) {
+    // Clear the LCD display sets x and y offsets to 0,0
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x00,BYTE);
+}
+
+void SerialLCD::print(char *data) {
+    // Print data to the LCD
+    _portPtr -> print(data);
+}
+
+void SerialLCD::print(char *data, byte x, byte y) {
+    // Print data at position given by x and y.
+    setPos(x,y);
+    print(data);
+}
+
+void SerialLCD::setBrightness(byte value) {
+    // Sets the LCD backlight brightness - adjusts duty cycle.
+    // value should be between 0 and 100.
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x02,BYTE);
+    _portPtr -> print(value,BYTE);
+}
+
+void SerialLCD::setX(byte x) {
+    // Set the x coordinate for where the next character will be drawn
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x18,BYTE);
+    _portPtr -> print(x,BYTE);
+}
+
+void SerialLCD::setY(byte y) {
+    // Set the y coordinate for where the next character will be drawn
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x19,BYTE);
+    _portPtr -> print(y,BYTE);
+}
+
+void SerialLCD::setPos(byte x, byte y) {
+    // Set x and y coordinates for where next character will be drawn
+    setX(x);
+    setY(y);
+}
+
+void SerialLCD::setPixel(byte x, byte y, byte state) {
+    // Set pixel and coordinate x,y to value given by state.
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x10,BYTE);
+    _portPtr -> print(x,BYTE);
+    _portPtr -> print(y,BYTE);
+    _portPtr -> print(state,BYTE);
+}
+
+void SerialLCD::drawLine(
+        byte startX, 
+        byte startY, 
+        byte endX, 
+        byte endY, 
+        byte state
+        )
+{
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x0C,BYTE);
+    _portPtr -> print(startX,BYTE);
+    _portPtr -> print(startY,BYTE);
+    _portPtr -> print(endX,BYTE);
+    _portPtr -> print(endY,BYTE);
+    _portPtr -> print(state,BYTE);
+}
+
+void SerialLCD::drawBox(
+        byte topLeftX, 
+        byte topLeftY, 
+        byte bottomRightX, 
+        byte bottomRightY, 
+        byte state
+        )
+{
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x0F,BYTE);
+    _portPtr -> print(topLeftX,BYTE);
+    _portPtr -> print(topLeftY,BYTE);
+    _portPtr -> print(bottomRightX,BYTE);
+    _portPtr -> print(bottomRightY,BYTE);
+    _portPtr -> print(state,BYTE);
+}
+
+void SerialLCD::drawCircle(
+        byte startX, 
+        byte startY, 
+        byte radius, 
+        byte state
+        )
+{
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x03,BYTE);
+    _portPtr -> print(startX,BYTE);
+    _portPtr -> print(startY,BYTE);
+    _portPtr -> print(radius,BYTE);
+    _portPtr -> print(state,BYTE);
+}
+
+void SerialLCD::drawFilledBox(
+        byte topLeftX, 
+        byte topLeftY, 
+        byte bottomRightX, 
+        byte bottomRightY, 
+        byte state
+        )
+{
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x12,BYTE);
+    _portPtr -> print(topLeftX,BYTE);
+    _portPtr -> print(topLeftY,BYTE);
+    _portPtr -> print(bottomRightX,BYTE);
+    _portPtr -> print(bottomRightY,BYTE);
+    _portPtr -> print(state,BYTE);
+}
+
+void SerialLCD::toggleAuxFont() {
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x08,BYTE);
+}
+
+void SerialLCD::toggleRevMode() {
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x14,BYTE);
+}
+
+void SerialLCD::toggleSplash() {
+    _portPtr -> print(0x7C,BYTE);
+    _portPtr -> print(0x15,BYTE);
+}
+

File lcd_photogate_v2/SerialLCD.h

+#ifndef _SERIAL_LCD_H_
+#define _SERIAL_LCD_H_
+#include "WProgram.h"
+
+
+class SerialLCD {
+    private:
+        Print *_portPtr;
+    public:
+        SerialLCD();
+        SerialLCD(Print &port);
+        void setPort(Print &port);
+        void clearScreen(void);
+        void setBrightness(byte value);
+        void print(char *data);
+        void print(char *data, byte x, byte y);
+        void setX(byte x);
+        void setY(byte y);
+        void setPos(byte x, byte y);
+        void setPixel(byte x, byte y, byte state);
+        void drawLine(byte startX, byte startY, byte endX, byte endY, byte state);
+        void drawBox(byte topLeftX, byte topLeftY, byte bottomRightX, byte bottomRightY, byte state);
+        void drawCircle(byte startX, byte startY, byte radius, byte state);
+        void drawFilledBox(byte topLeftX, byte topLeftY, byte bottomRightX, byte bottomRightY, byte state);
+        void toggleAuxFont();
+        void toggleRevMode(); 
+        void toggleSplash();
+};
+
+#endif

File lcd_photogate_v2/lcd_photogate.h

+#ifndef _LCD_PHOTOGATE_H_
+#define _LCD_PHOTOGATE_H_
+
+#define LOOP_DELAY 25
+
+// Timer parameters - 1kHz overflow on timer 2
+#define TIMER_TCCR2A 0b00000011 
+#define TIMER_TCCR2B 0b00001100  
+#define TIMER_OCR2A 249 
+
+#endif

File lcd_photogate_v2/lcd_photogate.pde

+#include <NewSoftSerial.h>
+#include "lcd_photogate.h"
+#include "SerialLCD.h"
+#include "Sensor.h"
+#include "DisplayHandler.h"
+#include "util/atomic.h"
+
+NewSoftSerial softSerial(7,6);
+DisplayHandler display(softSerial);
+Sensor photogate;
+
+void setup() {
+    softSerial.begin(115200);
+    delay(2500);
+    display.init();
+    display.showSplashScreen();
+    timerInit();
+}
+
+void loop() {
+    uint16_t period;
+    uint16_t currValue;
+
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+        //currValue = photogate.getCurrValue();
+        currValue = photogate.getMinValueInBuf();
+        period = photogate.getPeriod();
+    }
+
+    // Update display
+    display.setBrightness();
+    display.updatePeriodText(period);
+    display.updateTracePlot(currValue);
+    delay(LOOP_DELAY);
+}
+
+ISR(TIMER2_OVF_vect) {
+    // Timer 2 overflow interrupt service routine. Take photogate 
+    // sensor readings.
+    photogate.update();
+}
+
+void timerInit(void) {
+    // Initialize timer 2 - 1kHz overflow for reading photogate 
+    TCCR2A = TIMER_TCCR2A;
+    TCCR2B = TIMER_TCCR2B;
+    OCR2A = TIMER_OCR2A;
+    // Timer 2 overflow interrupt enable 
+    TIMSK2 |= (1<<TOIE2) | (0<<OCIE2A);
+    TCNT2 = 0;
+}
+