Mini-Octopus build from r@171

1 files changed, 200 insertions, 0 deletions

diff --git a/firmware/adc.c b/firmware/adc.c
new file mode 100644
index 0000000..a9449b7
--- /dev/null
+++ b/firmware/adc.c
@@ -0,0 +1,200 @@
+/*
+ * 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;
+}