/*
 * Copyright (c) 2007 empronix (http://www.empronix.com)
 * Author: Benedikt Sauter <sauter@empronix.com>
 * All rights reserved.
 *
 * Short descripton of file:
 *
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright 
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the following 
 *     disclaimer in the documentation and/or other materials provided 
 *     with the distribution.
 *   * Neither the name of the FH Augsburg nor the names of its 
 *     contributors may be used to endorse or promote products derived 
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES{} LOSS OF USE, 
 * DATA, OR PROFITS{} OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "common.h"
#include "protocol.h"
#include "adc.h"

void adc_parser(char *buf)
{
   switch(buf[0])
   {
      case CMD_ADC_INIT_PIN:
         adc_init_usb((int)buf[2]);
      break;
      case CMD_ADC_GET:
         adc_get_usb((int)buf[2]);
      break;
      case CMD_ADC_REF:
         adc_ref_usb((int)buf[2]);
      break;

      default:
         answer[0]=buf[0];
         answer[1]=RSP_UNKOWN_CMD;
         answer[2]=0;
         CommandAnswer(3);
    }
}

int adc_init(int pin)
{
   if (pin >= 33 && pin <= 40)
   {
      octopus.ports[pin] = PIN_AD;

      switch(pin)
      {
         case 40:	  break;
         case 39:	  break;
         case 38:	  break;
         case 37:	  break;
         case 36:	  break;
         case 35:	  break;
         case 34:	  break;
         case 33:	  break;
         default:
	         return RSP_IMPOSSIBLE_PIN_CONFIG;
      } 
      return RSP_OK; 
   }
   return RSP_UNKOWN_PIN;
}

void adc_init_usb(int pin)
{
   answer[0]=CMD_ADC_INIT_PIN;
   answer[1]= (unsigned char)adc_init(pin);
   answer[2]=0;

   CommandAnswer(3);
}

void adc_get_usb(int pin)
{
 
   uint16_t result;
   //uint8_t result[2];

   answer[0]=CMD_ADC_GET;
   answer[1]=adc_get(pin,&result);
   //result[0] = 0x77;
   //result[1] = 0x88;
   //answer[2]=(char)result[1];  //high
   //answer[3]=(char)result[0];  //low
   answer[2]=(char)(result>>8);  //high
   answer[3]=(char)(result);  //low
   CommandAnswer(4);
}


int adc_get(int pin, uint16_t *value)
{
   *value = 0;

   if (octopus.ports[pin] == PIN_AD)
   {
      switch (pin)
      {
         case 40: *value =_adc_read_channel(0); break;
         case 39: *value =_adc_read_channel(1); break;
         case 38: *value =_adc_read_channel(2); break;
         case 37: *value =_adc_read_channel(3); break;
         case 36: *value =_adc_read_channel(4); break;
         case 35: *value =_adc_read_channel(5); break;
         case 34: *value =_adc_read_channel(6); break;
         case 33: *value =_adc_read_channel(7); break;
         default:
	      return RSP_IMPOSSIBLE_PIN_CONFIG;
      } 
      return RSP_OK;
   } 
   else 
   {
      return RSP_WRONG_PIN_CONFIG;
   } 
}

void adc_ref_usb(int ref)
{
   answer[0]=CMD_ADC_REF;
   answer[1]=adc_ref(ref);
   CommandAnswer(2);
}

int adc_ref(int ref)
{
   ADMUX = 0x00;

   switch(ref){
      case PARAM_ADC_AREF:  break;
      case PARAM_ADC_AVCC:  ADMUX |= (1<<REFS0); break;
      case PARAM_ADC_INTERNAL:  ADMUX |= (1<<REFS1) | (1<<REFS0); break;
      default:
         return RSP_ERROR;
   }
   return RSP_OK;
}

uint16_t _adc_read_channel(int mux)
{
   int i;
   uint16_t result;
 
   ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0);    // Frequenzvorteiler 
                              // setzen auf 8 (1) und ADC aktivieren (1)
 
   //ADMUX |= (unsigned char)mux;                      // Kanal waehlen
   ADMUX = (ADMUX & 0xF0) | (unsigned char) mux; // select channel
  
   //ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen 
 
   /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

   ADCSRA |= (1<<ADSC);              // eine ADC-Wandlung 
   while ( ADCSRA & (1<<ADSC) ) {
     ;     // auf Abschluss der Konvertierung warten 
   }
   result = ADCW;  // ADCW muss einmal gelesen werden,
                  // sonst wird Ergebnis der nächsten Wandlung
                  // nicht übernommen.
 
   /* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
   result = 0; 
   for( i=0; i<4; i++ )
   {
      ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
      while ( ADCSRA & (1<<ADSC) ) {
         ;   // auf Abschluss der Konvertierung warten
      }
      result += ADCW;		    // Wandlungsergebnisse aufaddieren
   }
   ADCSRA &= ~(1<<ADEN);             // ADC deaktivieren (2)
 
   result /= 4;                     // Summe durch vier teilen = arithm. Mittelwert
 
   return result;
}