Revision 0:38f51c4f7655, committed 2015-08-11

Comitter:

Dannis_mbed

Date:

Tue Aug 11 08:41:49 2015 +0000

Commit message:

presentation version

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/PinDetect.h	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,501 @@
+/*
+    Copyright (c) 2010 Andy Kirkham
+ 
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+ 
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+ 
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+*/
+
+#ifndef AJK_PIN_DETECT_H
+#define AJK_PIN_DETECT_H
+
+#ifndef MBED_H
+#include "mbed.h"
+#endif
+
+#ifndef PINDETECT_PIN_ASSTERED
+#define PINDETECT_PIN_ASSTERED   1
+#endif
+
+#ifndef PINDETECT_SAMPLE_PERIOD
+#define PINDETECT_SAMPLE_PERIOD 20000
+#endif
+
+#ifndef PINDETECT_ASSERT_COUNT  
+#define PINDETECT_ASSERT_COUNT  1
+#endif
+
+#ifndef PINDETECT_HOLD_COUNT
+#define PINDETECT_HOLD_COUNT    50
+#endif
+
+namespace AjK {
+
+/** PinDetect adds mechanical switch debouncing to DigitialIn and interrupt callbacks.
+ *
+ * This is done by sampling the specified pin at regular intervals and detecting any
+ * change of state ( 0 -> 1 or 1 -> 0 ). When a state change is detected the attached
+ * callback handler is called. Additionally, if the pin stays in the same state after
+ * a state change for a defined period of time, an extra callback is made allowing a
+ * program to detect when a "key is pressed and held down" rather than a momentary
+ * key/switch press.
+ *
+ * All parameters are customisable which include:-
+ *  <ul>
+ *  <li> The sampling frequency. </li>
+ *  <li> The number of continuous samples until a state change is detected. </li> 
+ *  <li> The number of continuous samples until a key is assumed held after a state change. </li>
+ *  <li> The logic level which is assumed to be asserted (0volts or +volts). </li>
+ *  </ul>
+ *
+ * Only callbacks that have been attached will be called by the library.
+ *
+ * Example:
+ * @code
+ * #include "mbed.h"
+ * #include "PinDetect.h"
+ *
+ * PinDetect  pin( p30 );
+ * DigitialOut led1( LED1 );
+ * DigitialOut led2( LED2 );
+ * DigitialOut led3( LED3 );
+ * DigitialOut led4( LED4 );
+ *
+ * void keyPressed( void ) {
+ *     led2 = 1;
+ *     led3 = 0;
+ *     led4 = 0;
+ * }
+ *
+ * void keyReleased( void ) {
+ *     led2 = 0;
+ *     led3 = 0;
+ *     led4 = 0;
+ * }
+ *
+ * void keyPressedHeld( void ) {
+ *     led3 = 1;
+ * }
+ *
+ * void keyReleasedHeld( void ) {
+ *     led4 = 1;
+ * }
+ *
+ * int main() {
+ *
+ *     pin.mode( PullDown );
+ *     pin.attach_asserted( &keyPressed );
+ *     pin.attach_deasserted( &keyReleased );
+ *     pin.attach_asserted_held( &keyPressedHeld );
+ *     pin.attach_deasserted_held( &keyReleasedHeld );
+ *
+ *     // Sampling does not begin until you set a frequency.
+ *     // The default is 20ms. If you want a different frequency
+ *     // then pass the period in microseconds for example, for 10ms :-
+ *     //     pin.setSampleFrequency( 10000 );
+ *     //
+ *     pin.setSampleFrequency(); // Defaults to 20ms.
+ *
+ *     while( 1 ) {
+ *         led1 = !led1;
+ *         wait( 0.2 );
+ *     }
+ * }
+ * @endcode
+ *
+ * This example will flash led1 in a similar to a standard starting program.
+ *
+ * Applying a "1" (switch on) to pin 30 will switch on led2, removing the "1" to "0"
+ * (switch off) led2 goes out. Holding the "switch" at one for one second will switch
+ * on led3. An unasserted P30 (switched off) will, after one second illuminate led4
+ * when the deasserted calledback is called.
+ *
+ * The above is a very basic introduction. For more details:-
+ * @see example.h
+ */
+class PinDetect {
+
+protected:
+    DigitalIn   *_in;
+    Ticker      *_ticker;
+    int         _prevState;
+    int         _currentStateCounter;
+    int         _sampleTime;
+    int         _assertValue;
+    int         _samplesTillAssertReload;
+    int         _samplesTillAssert;
+    int         _samplesTillHeldReload;
+    int         _samplesTillHeld;
+    FunctionPointer _callbackAsserted;
+    FunctionPointer _callbackDeasserted;
+    FunctionPointer _callbackAssertedHeld;
+    FunctionPointer _callbackDeassertedHeld;
+    
+    /** initialise class
+     *
+     * @param PinName p is a valid pin that supports DigitalIn
+     * @param PinMode m The mode the DigitalIn should use.
+     */
+    void init(PinName p, PinMode m) {
+        _sampleTime              = PINDETECT_SAMPLE_PERIOD;
+        _samplesTillAssert       = PINDETECT_ASSERT_COUNT;
+        _samplesTillHeld         = 0;
+        _samplesTillAssertReload = PINDETECT_ASSERT_COUNT;
+        _samplesTillHeldReload   = PINDETECT_HOLD_COUNT;
+        _assertValue             = PINDETECT_PIN_ASSTERED;
+        
+        _in = new DigitalIn( p );
+        _in->mode( m );        
+        _prevState = _in->read();        
+        _ticker = new Ticker;
+    }
+    
+public:
+
+    friend class Ticker;
+    
+    PinDetect() { error("You must supply a PinName"); }
+
+    /** PinDetect constructor
+     *
+     * By default the PinMode is set to PullDown.
+     *
+     * @see http://mbed.org/handbook/DigitalIn
+     * @param p PinName is a valid pin that supports DigitalIn
+     */    
+    PinDetect(PinName p) {
+        init( p, PullDown );
+    }
+
+    /** PinDetect constructor
+     *
+     * @see http://mbed.org/handbook/DigitalIn
+     * @param PinName p is a valid pin that supports DigitalIn
+     * @param PinMode m The mode the DigitalIn should use.
+     */    
+    PinDetect(PinName p, PinMode m) {
+        init( p, m );
+    }
+    
+    /** PinDetect destructor
+     */    
+    ~PinDetect() {
+        if ( _ticker )  delete( _ticker );
+        if ( _in )      delete( _in );
+    }
+    
+    /** Set the sampling time in microseconds.
+     *
+     * @param int The time between pin samples in microseconds.
+     */
+    void setSampleFrequency(int i = PINDETECT_SAMPLE_PERIOD) { 
+        _sampleTime = i; 
+        _prevState  = _in->read();        
+        _ticker->attach_us( this, &PinDetect::isr, _sampleTime );
+    }
+    
+    /** Set the value used as assert.
+     *
+     * Defaults to 1 (ie if pin == 1 then pin asserted).
+     *
+     * @param int New assert value (1 or 0)
+     */
+    void setAssertValue (int i = PINDETECT_PIN_ASSTERED) { _assertValue = i & 1; }
+    
+    /** Set the number of continuous samples until assert assumed.
+     *
+     * Defaults to 1 (1 * sample frequency).
+     *
+     * @param int The number of continuous samples until assert assumed.
+     */    
+    void setSamplesTillAssert(int i) { _samplesTillAssertReload = i; }
+    
+    /** Set the number of continuous samples until held assumed.
+     *
+     * Defaults to 50 * sample frequency.
+     *
+     * @param int The number of continuous samples until held assumed.
+     */    
+    void setSamplesTillHeld(int i) { _samplesTillHeldReload = i; }
+    
+    /** Set the pin mode.
+     *
+     * @see http://mbed.org/projects/libraries/api/mbed/trunk/DigitalInOut#DigitalInOut.mode
+     * @param PinMode m The mode to pass on to the DigitalIn
+     */
+    void mode(PinMode m) { _in->mode( m ); }
+    
+    /** Attach a callback function 
+     *
+     * @code
+     *
+     * DigitalOut led1( LED1 );
+     * PinDetect pin( p30 );
+     *
+     * void myCallback( void ) {
+     *   led1 = 1;
+     * };
+     * 
+     * main() {
+     *     pin.attach_asserted( &myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is asserted.
+     * @param function A C function pointer
+     */
+    void attach_asserted(void (*function)(void)) {
+        _callbackAsserted.attach( function );
+    }
+    
+    /** Attach a callback object/method 
+     *
+     * @code
+     *
+     * class Bar {
+     *   public:
+     *     void myCallback( void ) { led1 = 1; }
+     * };
+     *
+     * DigitalOut led1( LED1 );
+     * PinDetect pin( p30 );
+     * Bar bar;
+     *
+     * main() {
+     *     pin.attach_asserted( &bar, &Bar::myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is asserted.
+     * @param object An object that conatins the callback method.
+     * @param method The method within the object to call.
+     */
+    template<typename T>
+    void attach_asserted(T *object, void (T::*member)(void)) {
+        _callbackAsserted.attach( object, member );        
+    }
+    
+    /** Attach a callback function 
+     *
+     * @code
+     *
+     * DigitalOut led1( LED1 );
+     * PinDetect pin( p30 );
+     *
+     * void myCallback( void ) {
+     *   led1 = 0;
+     * };
+     *
+     * main() {
+     *     pin.attach_deasserted( &myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is deasserted.
+     * @param function A C function pointer
+     */
+    void attach_deasserted(void (*function)(void)) {
+        _callbackDeasserted.attach( function );
+    }
+    
+    /** Attach a callback object/method
+     *
+     * @code
+     *
+     * class Bar {
+     *   public:
+     *     void myCallback( void ) { led1 = 0; }
+     * };
+     *
+     * DigitalOut led1( LED1 );
+     * PinDetect pin( p30 );
+     * Bar bar;
+     * 
+     * main() {
+     *     pin.attach_deasserted( &bar, &Bar::myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is deasserted.
+     * @param object An object that conatins the callback method.
+     * @param method The method within the object to call.
+     */
+    template<typename T>
+    void attach_deasserted(T *object, void (T::*member)(void)) {
+        _callbackDeasserted.attach( object, member );        
+    }
+    
+    /** Attach a callback function 
+     *
+     * @code
+     *
+     * DigitalOut led2( LED2 );
+     * PinDetect pin( p30 );
+     *
+     * void myCallback( void ) {
+     *   led2 = 1;
+     * };
+     *
+     * main() {
+     *     pin.attach_asserted_held( &myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is asserted and held.
+     * @param function A C function pointer
+     */
+    void attach_asserted_held(void (*function)(void)) {
+        _callbackAssertedHeld.attach( function );
+    }
+    
+    /** Attach a callback object/method
+     *
+     * @code
+     *
+     * class Bar {
+     *   public:
+     *     void myCallback( void ) { led2 = 0; }
+     * };
+     *
+     * DigitalOut led2( LED2 );
+     * PinDetect pin( p30 );
+     * Bar bar;
+     * 
+     * main() {
+     *     pin.attach_asserted_held( &bar, &Bar::myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is asserted and held.
+     * @param object An object that conatins the callback method.
+     * @param method The method within the object to call.
+     */
+    template<typename T>
+    void attach_asserted_held(T *object, void (T::*member)(void)) {
+        _callbackAssertedHeld.attach( object, member );        
+    }
+    
+    /** Attach a callback function 
+     *
+     * @code
+     *
+     * DigitalOut led3( LED3 );
+     * PinDetect pin( p30 );
+     *
+     * void myCallback( void ) {
+     *   led3 = 1;
+     * };
+     *
+     * main() {
+     *     pin.attach_deasserted_held( &myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is deasserted and held.
+     * @param function A C function pointer
+     */
+    void attach_deasserted_held(void (*function)(void)) {
+        _callbackDeassertedHeld.attach( function );
+    }
+    
+    /** Attach a callback object/method
+     *
+     * @code
+     *
+     * class Bar {
+     *   public:
+     *     void myCallback( void ) { led3 = 0; }
+     * };
+     *
+     * DigitalOut led3( LED3 );
+     * PinDetect pin( p30 );
+     * Bar bar;
+     * 
+     * main() {
+     *     pin.attach_deasserted_held( &bar, &Bar::myCallback );
+     * }
+     *
+     * @endcode
+     *
+     * Call this function when a pin is deasserted and held.
+     * @param object An object that conatins the callback method.
+     * @param method The method within the object to call.
+     */
+    template<typename T>
+    void attach_deasserted_held(T *object, void (T::*member)(void)) {
+        _callbackDeassertedHeld.attach( object, member );        
+    }
+    
+    /** operator int()
+     *
+     * Read the value of the pin being sampled.
+     */
+    operator int() { return _in->read(); }
+
+protected:    
+    /** The Ticker periodic callback function
+     */
+    void isr(void) {
+        int currentState = _in->read();
+    
+        if ( currentState != _prevState ) {
+            if ( _samplesTillAssert == 0 ) {
+                _prevState = currentState;
+                _samplesTillHeld = _samplesTillHeldReload;
+                if ( currentState == _assertValue ) 
+                    _callbackAsserted.call();
+                else                              
+                    _callbackDeasserted.call();
+            }
+            else {
+                _samplesTillAssert--;
+            }
+        }
+        else {
+            _samplesTillAssert = _samplesTillAssertReload;
+        }
+        
+        if ( _samplesTillHeld ) {
+            if ( _prevState == currentState ) {
+                _samplesTillHeld--;
+                if ( _samplesTillHeld == 0 ) {
+                    if ( currentState == _assertValue ) 
+                        _callbackAssertedHeld.call();
+                    else                              
+                        _callbackDeassertedHeld.call();
+                }
+            }
+            else {
+                _samplesTillHeld = 0;
+            }
+        }
+    }
+    
+};
+
+}; // namespace AjK ends.
+
+using namespace AjK;
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/circular_buffer.cpp	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,180 @@
+
+#ifndef CIRCULAR_BUFFER_CPP
+#define CIRCULAR_BUFFER_CPP
+
+#include <stdio.h>
+#include "circular_buffer.h"
+
+/*
+template<class T>
+circular_buffer<T>::circular_buffer()
+{
+    capacity = 0;
+    size = 0;
+
+    buffer = 0;
+
+    reset();
+}
+*/
+
+template<class T>
+circular_buffer<T>::circular_buffer(int tcapacity)
+{
+    capacity = tcapacity;
+    buffer = new T[capacity];
+
+    reset();
+}
+
+template<class T>
+circular_buffer<T>::~circular_buffer()
+{
+    if (buffer != 0)
+        delete[] buffer;
+}
+
+template<class T>
+void circular_buffer<T>::reset()
+{
+    start_pos = 0;
+    end_pos = 0;
+    size = 0;
+}
+
+template<class T>
+int circular_buffer<T>::get_capacity()
+{
+    return capacity;
+}
+
+template<class T>
+int circular_buffer<T>::get_size()
+{
+    return size;
+}
+
+template<class T>
+void circular_buffer<T>::push_back(T item)
+{
+    if (size  == capacity)
+        pop_front();
+
+    buffer[end_pos] = item;
+    increment(end_pos);
+    size++;
+}
+
+/*
+template<class T>
+void circular_buffer<T>::push_front(T item)
+{
+    if (size  == capacity)
+        pop_back();
+
+    buffer[start_pos] = item;
+    decrement(start_pos);
+    size++;
+}
+
+*/
+
+template<class T>
+void circular_buffer<T>::pop_back()
+{
+    if (size != 0)
+    {
+        size--;
+        decrement(end_pos);
+    }
+}
+
+template<class T>
+void circular_buffer<T>::pop_front()
+{
+    if (size != 0)
+    {
+        size--;
+        increment(start_pos);
+    }
+}
+
+template<class T>
+void circular_buffer<T>::increment(int& index)
+{
+    index++;
+    if (index >= capacity)
+        index = 0;
+}
+
+template<class T>
+void circular_buffer<T>::decrement(int& index)
+{
+    index--;
+    if (index < 0)
+        index = capacity - 1;
+}
+
+
+template<class T>
+int circular_buffer<T>::if_increment(int index)
+{
+    index++;
+    if (index >= capacity)
+        index = 0;
+
+    return index;
+}
+
+template<class T>
+int circular_buffer<T>::if_decrement(int index)
+{
+    index--;
+    if (index < capacity)
+        index = capacity - 1;
+
+    return index;
+}
+
+template<class T>
+T& circular_buffer<T>::front()
+{
+    return buffer[start_pos];
+}
+
+template<class T>
+T& circular_buffer<T>::back()
+{
+    return buffer[if_decrement(end_pos)];
+}
+
+
+template<class T>
+T& circular_buffer<T>::operator[](int index)
+{
+    int real_index = 0;
+
+//    if (size == 0)  // no item
+//        return NULL;
+
+    real_index = index + start_pos;
+    if (real_index >= capacity)
+        real_index -= capacity;
+
+    return buffer[real_index];
+}
+
+
+template<class T>
+T& circular_buffer<T>::at(int index)
+{
+    int real_index = 0;
+
+    real_index = index + start_pos;
+    if (real_index >= capacity)
+        real_index -= capacity;
+
+    return buffer[real_index];
+}
+
+#endif // CIRCULAR_BUFFER_CPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/circular_buffer.h	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,53 @@
+#ifndef CIRCULAR_BUFFER
+#define CIRCULAR_BUFFER
+
+
+template<class T>
+class circular_buffer
+{
+public:
+//    circular_buffer();
+    circular_buffer(int capacity);
+    ~circular_buffer();
+
+    int get_capacity(); // get the maximum capacity of the buf
+    int get_size();     // get the current item count
+
+    void push_back(T item);
+//    void push_front(T item);
+
+    void pop_back();
+    void pop_front();
+
+    T& front();
+    T& back();
+
+    T& at(int index);
+    T& operator[](int index);
+
+
+protected:
+
+    int capacity;
+    int size;
+    int start_pos;
+    int end_pos;
+
+    T *buffer;
+
+    void increment(int& index);
+    void decrement(int& index);
+
+    int if_increment(int index);
+    int if_decrement(int index);
+
+    void reset();
+
+
+};
+
+#include "circular_buffer.cpp"
+
+#endif // CIRCULAR_BUFFER
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,206 @@
+//////////////////////////////////////////////////////////////////////////////////////
+//                                                                                  //
+//      File        : main.cpp                                                      //
+//      Version     : 0.1                                                           //
+//      Initial     : 17 June 2015                                                  //
+//      Author      : Dany Brugman                                                  //
+//      Comment     : CANbus module analog sensor                                   //
+//                                                                                  //
+//                                                                                  //
+//      Changelog   :                                                               //
+//      Date:           Name:       Comment:                                        //
+//      19/06/2015      DNB         First version                                   //
+//                                                                                  //
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// includes                                                                         //
+//////////////////////////////////////////////////////////////////////////////////////
+#include "mbed.h"
+#include "PinDetect.h"
+#include "sensor.h"
+
+//////////////////////////////////////////////////////////////////////////////////////
+// device ID                                                                        //
+// CAN module ultrasonic heightsensor port side define HEIGHT_PORT                  //
+// CAN module ultrasonic heightsensor starboard side define HEIGHT_STARB            //
+//////////////////////////////////////////////////////////////////////////////////////
+#define HEIGHT_PORT
+//////////////////////////////////////////////////////////////////////////////////////
+// defines                                                                          //
+////////////////////////////////////////////////////////////////////////////////////// 
+#ifdef HEIGHT_PORT
+    #define DEVICE_ID   201    
+    #define REQ_STATUS  2003
+#endif  
+#ifdef HEIGHT_STARB
+    #define DEVICE_ID   202  
+    #define REQ_STATUS  2004
+#endif 
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                                                                                  //
+////////////////////////////////////////////////////////////////////////////////////// 
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// interrupts                                                                       //
+//////////////////////////////////////////////////////////////////////////////////////
+Ticker  ticker;
+Ticker  tActiveLedOn;
+Ticker  tled2on;
+Ticker  tReadSensor;
+
+Timeout tActiveLedOff;
+Timeout tled2off;
+
+//////////////////////////////////////////////////////////////////////////////////////
+// port declaration                                                                 //
+//////////////////////////////////////////////////////////////////////////////////////
+DigitalOut Led1(LED1);
+DigitalOut Led2(LED2);
+DigitalOut Led4(LED4);
+
+AnalogIn sensorPort(p19);
+Sensor sHeightSensor;
+CAN CANBus(p30, p29);
+
+Serial debug(USBTX, USBRX);
+
+//////////////////////////////////////////////////////////////////////////////////////
+// global variables                                                                 //
+//////////////////////////////////////////////////////////////////////////////////////
+char counter = 0;
+char cMessage, cStatus;
+
+int i;
+
+float fValue, fDistance;
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// functions declarations                                                           //
+//////////////////////////////////////////////////////////////////////////////////////
+
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// functions                                                                        //
+//////////////////////////////////////////////////////////////////////////////////////
+
+
+ 
+void send() 
+{
+    if(CANBus.write(CANMessage(1226, &counter, 1))) 
+    {
+        counter++;
+    } 
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Blink functions                                                                  //
+//////////////////////////////////////////////////////////////////////////////////////
+void tActiveLedOff_cb(void) 
+{
+    Led1 = 0;
+}
+ 
+void tActiveLedOn_cb(void) 
+{
+    Led1 = 1;
+    tActiveLedOff.detach();
+    tActiveLedOff.attach(&tActiveLedOff_cb, 0.05);
+}
+
+void tled2off_cb(void) 
+{
+    Led2 = 0;
+}
+ 
+void tled2on_cb(void) 
+{
+    Led2 = 1;
+    tled2off.detach();
+    tled2off.attach(&tled2off_cb, 0.05);
+}
+
+void tReadSensor_cb(void)
+{
+    sHeightSensor.vMeasureHeight();
+    Led4 = !Led4;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// main loop                                                                        //
+//////////////////////////////////////////////////////////////////////////////////////
+int main() {
+    debug.baud(115200);
+    debug.printf("\033[2J");
+    debug.printf("\033[9;10fDevice ID:%i\r\n", DEVICE_ID);
+    
+    Led1 = 1;
+    Led2 = 1;
+//////////////////////////////////////////////////////////////////////////////////////
+// schedule led events                                                              //
+//////////////////////////////////////////////////////////////////////////////////////    
+    tActiveLedOff.attach(&tActiveLedOn_cb, 0.05);
+    tActiveLedOn.attach(&tActiveLedOn_cb, 2);
+    tled2off.attach(&tled2on_cb, 0.05);
+    tled2on.attach(&tled2on_cb, 1);
+    tReadSensor.attach(&tReadSensor_cb, 0.09);        // call sensor read approx. 11 times/sec.
+
+    
+    CANBus.frequency(250000);
+    CANMessage msg;
+    
+    while(1) 
+    { 
+        if(CANBus.read(msg))
+        {
+            switch(msg.id)
+            {   // Send system status if MainModule requests
+                case REQ_STATUS:
+                            cStatus = 0xFF;                                     // OK
+                            if(msg.data[0] == 00) CANBus.write(CANMessage(DEVICE_ID, &cStatus, 1));
+                            wait_us(100);
+                            break;
+                // process stepper data direction/steps            
+                case DEVICE_ID:
+                            if(msg.data[0] == 0xff) 
+                            {
+                                sHeightSensor.setClearToSend(true);
+                                debug.printf("sensor clear");
+                                //tActiveLedOn.attach(&tActiveLedOn_cb, 0.5);   
+                            }
+                            else
+                            {
+                                sHeightSensor.setClearToSend(false);
+                                debug.printf("sensor stop send");
+                            }
+                            //cStatus = 0xFF;
+                            //CANBus.write(CANMessage(DEVICE_ID, &cStatus, 1));   // reply message received and executed
+                            //tActiveLedOn.attach(&tActiveLedOn_cb, 2);                     // indicate active
+                            break;
+                
+                // just dump received message (debug)
+                default:    
+                            debug.printf("Message id: %d\r\n", msg.id);
+                            debug.printf("Message length: %d\r\n", msg.len);
+                            for (i=0; i < msg.len; i++)
+                            {
+                                debug.printf("Message %d received: %d\r\n", i, msg.data[i]);
+                            }
+                            break;
+            }//end switch
+        }// end if
+        
+        wait(0.09);
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// EOF                                                                              //
+//////////////////////////////////////////////////////////////////////////////////////
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/7cff1c4259d7
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sensor.cpp	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,115 @@
+//////////////////////////////////////////////////////////////////////////////////////
+//                                                                                  //
+//      File        : ExtUI.cpp                                                     //
+//      Version     : 0.1                                                           //
+//      Initial     : 24 June 2015                                                  //
+//      Author      : Dany Brugman                                                  //
+//      Comment     : sensor class                                                  //
+//                                                                                  //
+//                                                                                  //
+//      Changelog   :                                                               //
+//      Date:           Name:       Comment:                                        //
+//      24/06/2015      DNB         First version                                   //
+//                                                                                  //
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// includes                                                                         //
+//////////////////////////////////////////////////////////////////////////////////////
+#include "sensor.h"
+
+//////////////////////////////////////////////////////////////////////////////////////
+// defines                                                                          //
+//////////////////////////////////////////////////////////////////////////////////////
+#define NEW_HEIGHT      203
+
+//////////////////////////////////////////////////////////////////////////////////////
+// constructor                                                                      //
+//////////////////////////////////////////////////////////////////////////////////////
+Sensor::Sensor() : 
+        uiCounter(0),
+        bClearToSend(0)
+{
+    init();
+};
+
+Sensor::~Sensor()
+{
+};
+
+extern Serial debug;
+extern CAN CANBus;
+extern AnalogIn sensorPort;
+
+circular_buffer<float> cbHeightBuffer(10);
+//////////////////////////////////////////////////////////////////////////////////////
+// initialisation                                                                   //
+//////////////////////////////////////////////////////////////////////////////////////
+void Sensor::init(void)
+{
+    
+}
+
+void Sensor::vMeasureHeight(void)
+{
+    fValue = sensorPort.read();
+    fDistance = (((fValue- 0.18f)* 122.22f) + 12);
+    cbHeightBuffer.push_back(fDistance);
+    uiHeight = (uint32_t) fDistance;
+    itoa(fDistance, cValue);
+    //cMessage = getValue();
+    if (bClearToSend)
+    {    
+        CANBus.write(CANMessage(NEW_HEIGHT, getValue(), 1));
+        debug.printf("Clear to send\t");
+    }
+    debug.printf("Sensor value int: %i\t", uiHeight);
+    debug.printf("send data: %c\r\n", getValue());
+}
+
+float Sensor::vAverageValue(void)
+{
+    int i;
+    int size = cbHeightBuffer.get_size();
+    for(i=0; i < size; i++) 
+    {
+        fAverageDistance += cbHeightBuffer.front(); 
+    }
+    fAverageDistance = fAverageDistance/size;
+    return fAverageDistance;
+}
+
+void Sensor::setClearToSend(bool Status)
+{
+    bClearToSend = Status;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// prep value                                                                       //
+//////////////////////////////////////////////////////////////////////////////////////
+void Sensor::itoa( uint32_t value, char *str)
+{   
+   int i,j;
+   char temp[4];
+   for(i=0; value > 0; i++){    
+       str[i] = value%10+'0';
+       value=value/10;
+    }
+    for(j=0;i>=0;j++,i--){
+        temp[j]=str[i-1];
+    }
+    for(i=0;i<j;i++){
+        str[i]=temp[i];
+    }
+    if(strcmp(str,"")== 0) str[0] = '0';    
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// get value                                                                        //
+//////////////////////////////////////////////////////////////////////////////////////
+char* Sensor::getValue(void) 
+{
+     static char* pValue;
+     pValue = cValue;
+     return pValue;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sensor.h	Tue Aug 11 08:41:49 2015 +0000
@@ -0,0 +1,48 @@
+#ifndef SENSOR_H_INCLUDED
+#define SENSOR_H_INCLUDED
+
+#include "mbed.h"
+#include "circular_buffer.h"
+
+class Sensor
+{
+    private:
+        // Resource
+          
+    
+        // variable
+        uint32_t uiHeight;
+        uint32_t uiCounter;
+        
+        float fValue, fDistance;
+        float fAverageDistance;
+        
+        char cValue[4];
+        char cMessage;
+                
+        bool bClearToSend;
+        bool bError;
+        
+        
+    public:
+        // Constructor
+        Sensor();
+        // Destructor
+        ~Sensor();
+        
+        // Gets
+        uint32_t getHeight(void);
+        
+        // Sets
+        int setHeight(uint32_t);
+        void setClearToSend(bool);
+
+        // Other functions
+        void init(void);
+        void vMeasureHeight(void);
+        float vAverageValue(void);
+        void itoa( uint32_t, char *);
+        char* getValue(void); 
+                
+};
+#endif
\ No newline at end of file