/**
 *
 *  analog.cpp
 *  Jan Dvorak z Vozerovic - dvorkaman@centrum.cz - dvorkaman.php5.cz
 */   
 
#ifndef analog_cpp
#define analog_cpp

#include "WProgram.h"
#include "analog.h"

/***************************************************
/**
 * Constructors
 * @param int input pin
 * @param int minimal change
 * @param int blind spot size
 * @param int minimal position
 * @param int maximal position
 * @param int middle position
 * @param int value range         
 */
Analog::Analog(int inputPin)
{
    configurate(inputPin, ANALOG_MINIMAL_CHANGE, ANALOG_BLIND_SPOT_SIZE, ANALOG_MIN_POSITION, ANALOG_MAX_POSITION, ANALOG_MIDDLE_POSITION, ANALOG_VALUE_RANGE);
} 

Analog::Analog(int inputPin, int minimalChange)
{       
    configurate(inputPin, minimalChange, ANALOG_BLIND_SPOT_SIZE, ANALOG_MIN_POSITION, ANALOG_MAX_POSITION, ANALOG_MIDDLE_POSITION, ANALOG_VALUE_RANGE);
}

Analog::Analog(int inputPin, int minimalChange, int blindSpotSize)
{
    configurate(inputPin, minimalChange, blindSpotSize, ANALOG_MIN_POSITION, ANALOG_MAX_POSITION, ANALOG_MIDDLE_POSITION, ANALOG_VALUE_RANGE);
}

Analog::Analog(int inputPin, int minimalChange, int blindSpotSize, int minPosition, int maxPosition)
{
    configurate(inputPin, minimalChange, blindSpotSize, minPosition, maxPosition, ANALOG_MIDDLE_POSITION, ANALOG_VALUE_RANGE);
}

Analog::Analog(int inputPin, int minimalChange, int blindSpotSize, int minPosition, int maxPosition, int middlePosition, int outputValueRange)
{
    configurate(inputPin, minimalChange, blindSpotSize, minPosition, maxPosition, middlePosition, outputValueRange);
}

/***************************************************
/**
 * Configurate
 * @params see constructors
 */
void Analog::configurate(int inputPin, int minimalChange, int blindSpotSize, int minPosition, int maxPosition, int middlePosition, int outputValueRange)
{
    _inputPin = inputPin;
    _minimalChange = minimalChange;
    _blindSpotSize = blindSpotSize;
    _minPosition = minPosition;
    _maxPosition = maxPosition;
    _middlePosition = middlePosition;
    _valueRange = outputValueRange;
    
    _lastSentValue = 0;
    _actualValue = 0;
    _previousInputValue = 0;
} 

/***************************************************
/**
 * Get actualPosition  
 * @returns {int} position <0..valueRange>            
 */
int Analog::getPosition()
{
    checkAndCalculatePosition();
    return _actualValue;
}

/***************************************************
/**
 * Position changes 
 * @returns {bool} if actual position changed minimal of <minimalChange>            
 */
boolean Analog::positionChanged()
{
    checkAndCalculatePosition();
    
    if( _lastSentValue == _actualValue )return false;
    if( abs(_lastSentValue - _actualValue) > _minimalChange || _actualValue == 0 || _actualValue == _valueRange || _actualValue == _valueRange / 2)
    {
      _lastSentValue = _actualValue;
      return true;
    }
    return false;
} 
 
/***************************************************
/**
 * Check and calculate position         
 */
void Analog::checkAndCalculatePosition()
{
    int a = analogRead(_inputPin);
    int range, val, valInRange;
  
    if( a == _previousInputValue )return; //no changes  
    _previousInputValue = a;
       
    //Case A) middle position
    if( abs(a - _middlePosition )<=_blindSpotSize/2 )
    {
        a = _valueRange/2;
    
    //Case B) front (positive) position
    }else if( a> _middlePosition ){
        range = _maxPosition - _middlePosition - _blindSpotSize/2;
        valInRange = a - _middlePosition - _blindSpotSize/2;
        
        a = (_valueRange / 2) +  map(valInRange, 0, range, 0, _valueRange / 2) + 1;
        if( a > _valueRange ) a = _valueRange;       
    
    //Case C) back (negative) position
    } else {
        range = _middlePosition - _blindSpotSize/2 - _minPosition;
        valInRange = a - _minPosition;
        
        a = map(valInRange, 0, range, 0, _valueRange / 2) - 1;
        if( a < 0 ) a = 0; 
    }
     
    //set
    _actualValue = a;
}

#endif