File content as of revision 1:7be9a82f3ab8:

#pragma once

#include "mbed.h"
#include "LM75B.h"
#include "MMA7660.h"

#include "Vector.hpp"
#include "Utils.h"

template <class Parent>
class FrdmK64f_AppShield_Input : public Parent
{
public: // List of manged Inputs

    enum IDBinaryInput
    {
        JoystickUp,
        JoystickDown,
        JoystickLeft,
        JoystickRight,
        JoystickMiddle,
        IDBinaryInput_MAX
    };
    
    enum IDAnalogInput
    {
        PotLeft,
        PotRight,
        Temp
    };
    
    enum IDVectorInput
    {
        Accel
    };

private:
    
    // Joystick
    InterruptIn         _joystickUp;
    InterruptIn         _joystickDown;
    InterruptIn         _joystickLeft;
    InterruptIn         _joystickRight;
    InterruptIn         _joystickMiddle;
    bool                _joystickEnable[IDBinaryInput_MAX];
    
    // Potentiometers
    AnalogIn            _potLeft;
    AnalogIn            _potRight;
    float               _potLeftValue;
    float               _potRightValue;
    float               _potLeftPrecision;
    float               _potRightPrecision;

    // Tempeture sensor
    LM75B               _temp;
    float               _tempValue;
    float               _tempPrecision;
    
    // Accelerometer
    MMA7660             _accel;
    Vector<float>       _accelValue;
    float               _accelPrecision;
    
public:

    FrdmK64f_AppShield_Input(void)
        : _joystickUp(A2), _joystickDown(A3), _joystickLeft(A4), _joystickRight(A5), _joystickMiddle(D4),
        _potLeft(A0), _potRight(A1), _potLeftValue(0.0f), _potRightValue(0.0f), _potLeftPrecision(1000.0f), _potRightPrecision(1000.0f),
        _temp(D14, D15), _tempValue(0.0f), _tempPrecision(10.0f),
        _accel(I2C_SDA, I2C_SCL), _accelPrecision(10.0f)
    {
        memset(_joystickEnable, 1, sizeof(_joystickEnable));
        
        _joystickUp.rise(this, &FrdmK64f_AppShield_Input::onJoystickUpRise);
        _joystickUp.fall(this, &FrdmK64f_AppShield_Input::onJoystickUpFall);
        _joystickDown.rise(this, &FrdmK64f_AppShield_Input::onJoystickDownRise);
        _joystickDown.fall(this, &FrdmK64f_AppShield_Input::onJoystickDownFall);
        _joystickLeft.rise(this, &FrdmK64f_AppShield_Input::onJoystickLeftRise);
        _joystickLeft.fall(this, &FrdmK64f_AppShield_Input::onJoystickLeftFall);
        _joystickRight.rise(this, &FrdmK64f_AppShield_Input::onJoystickRightRise);
        _joystickRight.fall(this, &FrdmK64f_AppShield_Input::onJoystickRightFall);
        _joystickMiddle.rise(this, &FrdmK64f_AppShield_Input::onJoystickMiddleRise);
        _joystickMiddle.fall(this, &FrdmK64f_AppShield_Input::onJoystickMiddleFall);
        
        _potLeftValue = prec(_potLeft, _potLeftPrecision);
        _potRightValue = prec(_potRight, _potRightPrecision);
        _tempValue = prec(_temp.read(), _tempPrecision);
    }
    
    using   Parent::setEnable;
    void    setEnable(FrdmK64f_AppShield_Input::IDBinaryInput inp, bool act) { _joystickEnable[inp] = act; }
    
    void    setPotLeftPrecision(short int pres) { _potLeftPrecision = pow(10.0f, pres); }
    void    setPotRightPrecision(short int pres) { _potRightPrecision = pow(10.0f, pres); }
    void    setTempPrecision(short int pres) { _tempPrecision = pow(10.0f, pres); }
    void    setAccelPrecision(short int pres) { _accelPrecision = pow(10.0f, pres); }
    
    // Not interresting section (do not use those methods)
    // Callbacks for joystick
    void    onJoystickUpRise(void) { if (_joystickEnable[JoystickUp]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickUp, Event::Rise)); }
    void    onJoystickUpFall(void) { if (_joystickEnable[JoystickUp]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickUp, Event::Fall)); }
    void    onJoystickDownRise(void) { if (_joystickEnable[JoystickDown]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickDown, Event::Rise)); }
    void    onJoystickDownFall(void) { if (_joystickEnable[JoystickDown]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickDown, Event::Fall)); }
    void    onJoystickLeftRise(void) { if (_joystickEnable[JoystickLeft]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickLeft, Event::Rise)); }
    void    onJoystickLeftFall(void) { if (_joystickEnable[JoystickLeft]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickLeft, Event::Fall)); }
    void    onJoystickRightRise(void) { if (_joystickEnable[JoystickRight]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickRight, Event::Rise)); }
    void    onJoystickRightFall(void) { if (_joystickEnable[JoystickRight]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickRight, Event::Fall)); }
    void    onJoystickMiddleRise(void) { if (_joystickEnable[JoystickMiddle]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickMiddle, Event::Rise)); }
    void    onJoystickMiddleFall(void) { if (_joystickEnable[JoystickMiddle]) Parent::_events.push(Event(Event::AppShield, Event::BinaryInput, JoystickMiddle, Event::Fall)); }
    
    // Callback for others sensors
    virtual void    chechAnalog(void)
    {
        Parent::chechAnalog();
        {
            Event   event(Event::AppShield, Event::AnalogInput, PotLeft, prec(_potLeft, _potLeftPrecision));
            if (event.analog != _potLeftValue)
            {
                _potLeftValue = event.analog;
                Parent::_events.push(event);
            }
        }
        {
            Event   event(Event::AppShield, Event::AnalogInput, PotRight, prec(_potRight, _potRightPrecision));
            if (event.analog != _potRightValue)
            {
                _potRightValue = event.analog;
                Parent::_events.push(event);
            }
        }
        {
            Event   event(Event::AppShield, Event::AnalogInput, Temp, prec(_temp.read(), _tempPrecision));
            if (event.analog != _tempValue)
            {
                _tempValue = event.analog;
                Parent::_events.push(event);
            }
        }
        {
            Event   event(Event::AppShield, Event::VectorInput, Accel, Vector<float>(prec(_accel.x(), _accelPrecision), prec(_accel.y(), _accelPrecision), prec(_accel.z(), _accelPrecision)));
            if (!(event.vector.eq(_accelValue, 1.0f / _accelPrecision)))
            {
                _accelValue = event.vector;
                Parent::_events.push(event);
            }
        }
    }
};