/*
 * 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"

#include <stdio.h>
#include "debug.h"


void adc_parser(char *buf)
{
  //debugf("adc parser CMD %02x\n",buf[0]);
   switch(buf[0])
   {
      case CMD_ADC_INIT_PIN:
         adc_init_usb(buf[2]);
        break;
      case CMD_ADC_DEINIT_PIN:
         adc_deinit_usb(buf[2]);
        break;
      case CMD_ADC_GET:
         adc_get_usb(buf[2]);
        break;
      case CMD_ADC_REF:
         adc_ref_usb(buf[2]);
        break;

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

int adc_init(uint8_t pin)
{
  if (pin >= 10 && pin <= 17)
  {
     octopus.ports[pin] = PIN_AD;
     ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen
     return RSP_OK; 
  }

  return RSP_UNKOWN_PIN;
}

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

   CommandAnswer(3);
}

int adc_deinit(uint8_t pin)
{
  if (octopus.ports[pin] == PIN_AD)
  {
     octopus.ports[pin] = PIN_NONE;
     return RSP_OK; 
  }

  return RSP_UNKOWN_PIN;
}

void adc_deinit_usb(uint8_t pin)
{
   answer[0]=CMD_ADC_DEINIT_PIN;
   answer[1]= (unsigned char)adc_deinit(pin);
   answer[2]=0;

   CommandAnswer(3);
}

void adc_get_usb(uint8_t 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(uint8_t pin, uint16_t *value)
{
  *value = 0;

  if (octopus.ports[pin] == PIN_AD)
  {
    // 40  => 0
    // 39  => 1
    // 38  => 2
    // pin  => 40-pin
    *value =_adc_read_channel(17 - pin);
    debugf("Wert %i\r\n",*value);
    return RSP_OK;
  }
  else 
    return RSP_WRONG_PIN_CONFIG;
}

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

int adc_ref(uint8_t 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(uint8_t mux)
{
   int i;
   uint16_t result;

   //ADMUX |= mux;                      // Kanal waehlen
 
   ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0);    // Frequenzvorteiler 
                              // setzen auf 8 (1) und ADC aktivieren (1)
 
   ADMUX = (ADMUX & 0xF0) | 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;
}