PIC18f 67j60 ADC Problem

Hallo,
bei mir klappt die Umwandlung von einem Spanungswert zwischen 0,8 und 
3,3 Volt nicht richtig.
Im Ergebnisregister ADRESH und ADRESL stehen immer die gleiche Werte 
egal, wenn ich 1V oder z.B. 2V oder 3Volt am Eingangspin bereitstelle.
Die Werte im ADRESH und ADRESL Register ändern sich, wenn ich die 
Versorgungsspanung vom Kontroller ganz abtrenne. (Kontroller 
positioniert auf einer Platte mit Webmanagment, wo auf der Seite 
Ergebnisse stehen ->Bild)
Datenblatt: http://www.uploadarea.de/files/bgqh1mrewibz8w8bo1e91gzjj.pdf
Hier ist komlette Code aus Datei CustomHTTPApp.c ,wo das Ganze 
ausgeführt wird:

#define __CUSTOMHTTPAPP_C
#include "TCPIPConfig.h"
#if defined(STACK_USE_HTTP2_SERVER)
#include "TCPIP Stack/TCPIP.h"
#include "MainDemo.h"    // Needed for SaveAppConfig() prototype
#include "ADC.h"

/*###################################################################### 
######*/

unsigned int ADC_Convert_Spgswert(void);
unsigned char ADC_Convert_Testvariable(void);

void ADC_Init(void);
BOOL RuckgabewertInput1=0;
BOOL RuckgabewertInput2=0;
BOOL RuckgabewertInput3=0;
BOOL RuckgabewertInput4=0;

unsigned int valuemax2;

HTTP_IO_RESULT HTTPExecutePost(void)
{
  BYTE filename[20];
  MPFSGetFilename(curHTTP.file, filename, sizeof(filename));
}

BYTE HTTPNeedsAuth(BYTE* cFile)
{
  return 0x80;      // No authentication required
}

#if defined(HTTP_USE_AUTHENTICATION)
BYTE HTTPCheckAuth(BYTE* cUser, BYTE* cPass)
{
  return 0x00;      // Provided user/pass is invalid
}
#endif

HTTP_IO_RESULT HTTPExecuteGet(void)
{
  BYTE *ptr;
  BYTE filename[20];

  MPFSGetFilename(curHTTP.file, filename, 20);//Make sure BYTE 
filename[] above is large enough for your longest name

  if(!memcmppgm2ram(filename, "forms.htm",9))
  {
    ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led4");
    if(ptr){                     //^ ptr wird dem led4 wert zugewiesen
       LED5_IO = (*ptr == '1');    // RF5
      RuckgabewertInput4= (*ptr == '1');
        }
    ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led3");
    if(ptr){
      LED4_IO = (*ptr == '1');  // RF4
      RuckgabewertInput3= (*ptr == '1');
        }
    ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led2");
    if(ptr){
      LED3_IO = (*ptr == '1');  // RF3
      RuckgabewertInput2= (*ptr == '1');
        }
    ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led1");
    if(ptr){
      LED2_IO = (*ptr == '1');  // RF2
      RuckgabewertInput1= (*ptr == '1');
        }
  }
return HTTP_IO_DONE;
}

void HTTPPrint_ledSelected(WORD num, WORD state)
{
  switch (num)
  {
    case 4: if ((((RuckgabewertInput4==1)&& (state==TRUE)) || 
((RuckgabewertInput4==0)&& (state==FALSE))))
        {          TCPPutROMString(sktHTTP, (ROM BYTE*)"SELECTED"); 
}
        break;
    case 3: if ((((RuckgabewertInput3==1)&& (state==TRUE)) || 
((RuckgabewertInput3==0)&& (state==FALSE))))
        {          TCPPutROMString(sktHTTP, (ROM BYTE*)"SELECTED"); 
}
        break;
    case 2: if ((((RuckgabewertInput2==1)&& (state==TRUE)) || 
((RuckgabewertInput2==0)&& (state==FALSE))))
        {          TCPPutROMString(sktHTTP, (ROM BYTE*)"SELECTED"); 
}
        break;
    case 1: if ((((RuckgabewertInput1==1)&& (state==TRUE)) || 
((RuckgabewertInput1==0)&& (state==FALSE))))
        {          TCPPutROMString(sktHTTP, (ROM BYTE*)"SELECTED"); 
}
        break;

    default:      num = 0;
  }
return;
}

void HTTPPrint_config_led (WORD num)
{
switch (num)
    {
  case 1:
  TCPPutString(sktHTTP, HTTPGetROMArg(curHTTP.data, (ROM BYTE 
*)"led1"));
  break;
  case 2:
  TCPPutString(sktHTTP, HTTPGetROMArg(curHTTP.data, (ROM BYTE 
*)"led2"));
  break;
  case 3:
  TCPPutString(sktHTTP, HTTPGetROMArg(curHTTP.data, (ROM BYTE 
*)"led3"));
  break;
  case 4:
  TCPPutString(sktHTTP, HTTPGetROMArg(curHTTP.data, (ROM BYTE 
*)"led4"));
  break;
  default: break;
    }
}

void HTTPPrint_Spgswert(void)
{

  BYTE TestArray[12];         //="MAXIM12\n"; //BYTE *TestPtr= 
"Maxim34\n";
  ADC_Init();
  ADC_Convert_Spgswert();
  uitoa (ADRESH,TestArray);
  TCPPutString(sktHTTP,TestArray);
            //TCPPutString(sktHTTP,&TestPtr);
            //TCPPutROMString(sktHTTP,(ROM 
BYTE*)ADC_Convert_Spgswert());
            //  TCPPutROMString(sktHTTP,(ROM BYTE*)"TEST");
            //TCPPutString(sktHTTP, HTTPGetROMArg(curHTTP.data, (ROM 
BYTE *)"led4"));
  return;
}

void HTTPPrint_Spgswertneu(void)
{
  BYTE TestArray[12]; //
   uitoa (ADRESL,TestArray);  // Umspeichern von Ergebnis fuer Rückgabe 
des Wertes
  TCPPutString(sktHTTP,TestArray);    // Rückgabe des Wertes
}
void HTTPPrint_Spgswerterg(void)
{
  BYTE TestArray[12]; //BYTE *TestPtr= "Maxim34\n";
   uitoa (valuemax2,TestArray);
  TCPPutString(sktHTTP,TestArray);
}

void ADC_Init(void)
{   ADCON0bits.ADON = 1;  //ADC einschalten
  ADCON1 = 0b00011011; // 0bxxxx1011 schaltet i/O von AN0 bis AN3 als 
Analog, ab AN4 als Digital
            //  0b--01xxxx VCFG0 [VREF+ bei(AN3)] als + A/Eingang
  ADCON0 = 0b00001100; // 0bxx0011xx; verbinden ADC mit dem Eingang AN3 
/RF2
  ADCON2 = 0b00100101; //ADCON2 = 0bx-xxx101; Frequenzverhältnis 
zwischen ADC-Takt und PIC-Takt
            //ADCON2 = 0bx-000xxx; für korrekte Messung: genug Zeit für 
Um-/Aufladung des Kondensators
             //ADCON2 = 0b0-xxxxxx; Links oder rechts von ADRESH ADRESL 
Register anhängen
// ADRESL.right 000 - Zeit automatisch
//  ADCON2 = 0b00101101; // Zeit abgeleitet von A/D RC oscillator . 101 
FOSC/32 Frequenz 22.86 MHz
  //ADCON0 |= 0x01;   // ADC ein   //ADCON0 &= ~(0x01); // ADC aus
}

unsigned int ADC_Convert_Spgswert(void)
{
  ADCON0bits.GO = 1;             // start an ADC conversion and return 
the 8 most-significant bits of the result
    while (ADCON0bits.GO == 1);    // wait for it to complete
  valuemax2 = ADRESH;           //value = (int)ADRESH;
  valuemax2 <<= 8;
  valuemax2 |= ADRESL;
    valuemax2 >>= 6;


 return valuemax2;
}