PIC16F690 AN8 bis AN11 nicht nutzbar

[Georg K. (gkeller)]

Hallo,
ich kämpfe seit einiger zeit mit einem PIC16F690 und den AD Ports AN8 
bis AN11. Ich bekomme die einfach nicht als Analog IN geschaltet. Mit 
den Ports AN0..AN7 geht es ohne Probleme.

Aufgefallen war es mir, als in der Schaltung der AN8 und AN9 einfach 
nicht das erwartete Ergebnis lieferte. Am Pin liegt allerdings die 
analoge Spannung an. Also Verdrahtung ausgeschlossen.

Ich habe dann mal den Simulator bemüht und mir die I/O Pins angesehen. 
Dabei habe ich festgestellt, die stehen anstatt auf Ain immer auf Din.

Nun habe ich ein kleines C Programm geschrieben um das mal zu testen, 
komme aber nicht dahinter. AN8..AN11 müssten doch über ANSELH gesteuert 
werden. Egal was ich da eintrage, nix ändert sich. Bei den unteren AD 
Ports geht es wie gewünscht ....

Hier der C-Code:
#include <stdio.h>
#include <stdlib.h>
#include <xc.h>                             //Use this to include the 
device header for your PIC.

#define _XTAL_FREQ 8000000
#pragma config FOSC=INTRCIO, WDTE=OFF, PWRTE=OFF, MCLRE=ON, BOREN=OFF, 
IESO=OFF, FCMEN=OFF
/*
 *
 */
volatile unsigned int uart_data;
int main(int argc, char** argv) {
//
//    Basic Setup der HW
//
    ANSEL   = 0b11111111;
    ANSELH  = 0b10001111;
    PORTA   = 0;
    PORTB   = 0;
    PORTC   = 0;
    TRISC   = 0b11111111;
    TRISB   = 0b00110000;

    ADCON0bits.CHS0     = 0;
    ADCON0bits.CHS1     = 0;
    ADCON0bits.CHS2     = 0;
    ADCON0bits.CHS3     = 1;
    while(1) {
        __delay_ms(1000);
    }
    return (EXIT_SUCCESS);
}

Hat jemand eine Idee oder weiß was ich falsch mache?
Vielen Dank, Georg

[Frank K. (fchk)]

Georg Keller schrieb:

>     ANSELH  = 0b10001111;

Warum ist Bit 7 gesetzt?

fchk

[Georg K. (gkeller)]

Ups. Ist nicht bewusst gesetzt. Ändert aber nix am Ergebnis da von 
ANSELH nur die unteren 4BIT genutzt werden.

[Jochen-paul S. (picfan)]

Hallo,
hab mal das Datenblatt angeschaut. Hast du möglicherweise das SPI 
oder/und UART aktiviert?
Gruss picfan

[Georg K. (gkeller)]

Hallo,
Hab ich auch schon vermutet. In der minimalen config habe ich es nicht 
verwendet bzw. nicht bewusst gesetzt.

Im Datenblatt habe ich keine weiteren Register gefunden die gesetzt 
werden müssten.

Viele Grüße Georg

[X4U (Gast)]

Falschen Pic eingestellt?

Georg Keller schrieb:
> Bei den unteren AD Ports geht es wie gewünscht ....

[Georg K. (gkeller)]

Hallo,
Der eingestellte Typ ist korrekt, hab ich mehrfach geprüft.

Gibt es jemanden, der es schon einmal mit einem 16F690 gemacht hat und 
einen der AD Ports die mit dem ANSELH Register selektiert werden zum 
laufen brachte?

Gruß Georg

[X4U (Gast)]

Sieht alles gut und richtig aus.

Zeig doch mal den Rest vom Code (wo das Adresult gelesen wird).

Versuchsweise mal einen der Eingänge mit einen der funzt Brücken. Die 
müssen dann ja das gleiche Ergebnis haben (sonst Hardware böse).

[castlerock (Gast)]

Deine Tristate ist leider inkorrekt. Die Analog Eingängen müssen als 
EINGANG definiert sein.

FALSCH:
    TRISC   = 0b11111111;
    TRISB   = 0b00110000;

RICHTIG:
    TRISC   = 0b11111111;
    TRISB   = 0b00111111;

[castlerock (Gast)]

Soory, Falsche PIC im kopf gehabt :-(
deine TRIS einstellung seht richtig aus.

Ist deine TRISA auch definiert?

[Georg K. (gkeller)]

Hallo,

so ich poste jetzt mal das Programm - zumindest die relevanten Teile:

Im Simulator habe ich den Breakpoint auf die "for 
(kanal=0;kanal<=3;kanal++) {" Zeile gesetzt und dann ist der PORT Status 
wie im Screenshot angehängt.

Vielleicht hilft das ....
Vielen Dank für die Mithilfe, Georg

Hier das Hauptprogramm:

/*
 * File:   main.c
 * Author: gkeller
 *
 * Created on 23. März 2015, 00:55
 * Notice:      
 *              
 *              Ausgabe des 10 A/D Wandler Wetes im Dezimalformat auf die RS232
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>                           
#include <xc.h>                             

#define _XTAL_FREQ 8000000
#pragma config FOSC=INTRCIO, WDTE=OFF, PWRTE=OFF, MCLRE=ON, BOREN=OFF, IESO=OFF, FCMEN=OFF

// Globals
volatile unsigned int uart_data;            // use 'volatile' qualifer as this is changed in ISR


int main(int argc, char** argv) {
//
//    deklaration von Funktionen
//    
    void Hardware_basic_init (void);
    void Hardware_porta_test (void);
    void Hardware_portc_test (void);
    void uart_xmit(unsigned int mydata_byte);
    void uart_xmit_logo(void);
    void Hardware_setup_Ports (void);
    void Hardware_setup_RS232 (void);
    void ADC_SC1_select(unsigned char);
    float ADC_get_value(unsigned char ADC_channel);

//
//    Hauptprogramm
//
     int i;                                     // Variable für Schleifen
     unsigned char kanal = 0;
     

//
//     Hier sind die Variablen für die AD Wandler Steuerung definiert
//
     char * ADCfloat_value_text;
     char * RS232_int_value;
     float AKKU_min = 10.5;
     float AKKU_max = 14.4;
     float ADCfloat_wert;

//
//     Flag das die Ladung aktiviert ist und das Laderelais geschaltet hat
//
     unsigned int charge;
     charge = 0;


//
//     Flag das der Akku auf die Last geschaltet ist
//
     unsigned int DCPower;
     DCPower = 0;

//
//     Variablen zur Steuerung des Ladeverhaltens
//
     int tmp;
     unsigned int hysterese = 0;
     unsigned int hysterese_zaehler = 50;

//
//     Initialisiere die weitere Hardware
//
        Hardware_basic_init();
        Hardware_setup_RS232();
        Hardware_setup_Ports();

        uart_xmit_logo();

        while (1) {

         Hardware_portc_test();
         Hardware_porta_test();

//
//         Frage die 4 AD Kanäle ab und gib den Wert auf der RS232 aus
//
         for (kanal=0;kanal<=3;kanal++) {

             ADCfloat_value_text = ftoa(ADC_get_value(kanal),&tmp);

            i = 0;
            while (i <= 3) { // wie viele Dezimalstellen hat der 10 Bit Wert?
                uart_xmit(ADCfloat_value_text[i]);
                i++;
            }
            //
            //            Ausgabe des Wertes an der RS232
            //
            uart_xmit(' ');
            uart_xmit('V');
            uart_xmit(':');
            uart_xmit(kanal + 48); // ASCII "0" = DEZIMAL 48

            uart_xmit(13); // CR
            uart_xmit(10); // LF
         }
            uart_xmit(13); // CR
            uart_xmit(10); //
            __delay_ms(2000);
     }
    return (0);
}

und hier das File mit den HW Setup Routinen

#include <stdio.h>
#include <stdlib.h>
#include <math.h>                           // Use this for TRUNC ...
#include <xc.h>                             //Use this to include the device header for your PIC.
#define _XTAL_FREQ 8000000

void Hardware_setup_RS232 (void) {
    //*************************************************************************************
    // Set up the UART
    // Note: See the datasheet for tables with the values of SPBRGH:SPBRGL already
    // calculated based on different values of Fosc and BRGH and desired
    // baud rates.
    //*************************************************************************************
    TXSTAbits.BRGH=0;                           // select low speed Baud Rate (see baud rate calcs below)
    TXSTAbits.TX9=0;                            // select 8 data bits
    TXSTAbits.TXEN = 1;                         // enable transmit
    RCSTAbits.SPEN=1;                           // serial port is enabled
    RCSTAbits.RX9=0;                            // select 8 data bits
    RCSTAbits.CREN=1;                           // receive enabled

    // calculate values of SPBRGL and SPBRGH based on the desired baud rate
    //
    // For 8 bit Async mode with BRGH=0: Desired Baud rate = Fosc/64([SPBRGH:SPBRGL]+1)
    // For 8 bit Async mode with BRGH=1: Desired Baud rate = Fosc/16([SPBRGH:SPBRGL]+1)

    // For our example,we will use BRGH=0,Fosc=16Mhz and we want baud rate=9600
    //
    //  9600 = Fosc/64([SPBRGH:SPBRGL]+1)
    //  9600 = Fosc/64(X+1)
    //  9600 = Fosc/64X + 64
    //  9600(64X + 64) = Fosc
    //  X = [Fosc/(9600)(64)]-1
    //  X = [16000000/(9600)(64)] -1
    //  X = SPBRGH:SPBRGL = 25.01 (round to 25)

    SPBRG=25;                                   // here is calculated value of SPBRGH and SPBRGL
    SPBRGH=0;

    PIR1bits.RCIF=0;                            // make sure receive interrupt flag is clear
    PIE1bits.RCIE=1;                            // enable UART Receive interrupt
    INTCONbits.PEIE = 1;                        // Enable peripheral interrupt
    INTCONbits.GIE = 1;                         // enable global interrupt

    __delay_ms(50);                            // give time for voltage levels on board to settle
}

void Hardware_setup_Ports (void) {
//
//    Hier werden die Ports initialisiert Digital I/O und AD
//
//
//    All IO-Ports set to Digital I/O per Default mit Deafult Wert = 0
//
    PORTA   = 0;
    PORTB   = 0;
    PORTC   = 0;
    ANSELH  = 0;
    ANSEL   = 0;
//
//    Setup der Ausgänge
//


//    Relais für Ladestrom und DC Verbraucher
    TRISAbits.TRISA4    = 0;
    TRISAbits.TRISA5    = 0;

//    Status LEDs
    TRISCbits.TRISC0    = 0;
    TRISCbits.TRISC1    = 0;

//    AD-Wandler
//    Generelle CONFIG
//
     TRISC   = 0b11001100;                       // AN9,AN8,AN7,AN6 auf analog IN
     ANSEL   = 0b11000000;
     ANSELH  = 0b00001111;
//    Set A/D Conversion Clock to Fosc/16
     ADCON1bits.ADCS = 6;
//    Enable A/D Converter
     ADCON0bits.ADON = 1;
//        Voltage Reference set to VDD
//        eine Einheit = 5V / 1024 = 0,0048828125V
     ADCON0bits.VCFG = 0;
//    Set to right formatted
     ADCON0bits.ADFM = 1;
}

void Hardware_basic_init (void) {
//
//    Basic Setup der HW
//
    OSCCON  = 0b011100000;
    ANSEL   = 0b11000000;
    ANSELH  = 0b00001111;
    PORTA   = 0;
    PORTB   = 0;
    PORTC   = 0;
    TRISA   = 0b00000000;
    TRISB   = 0b11111111;
    TRISC   = 0b11001100;                       // AN9,AN8,AN7,AN6 auf analog IN

    INTCON  = 0b00000000;                       // Disable all Interrupts
    PIE1    = 0b00000000;                       // Disable all PERIPHERAL Interrupts
}

void Hardware_portc_test (void) {
//
//    Basic Setup der HW
//
    PORTC   = 0;
    __delay_ms(500);

    PORTCbits.RC0   = 1;
    __delay_ms(500);
    PORTCbits.RC1   = 1;
    __delay_ms(500);
    PORTCbits.RC4   = 1;
    __delay_ms(500);
    PORTCbits.RC5   = 1;
}

void Hardware_porta_test (void) {
//
//    Basic Setup der HW
//
    PORTA   = 0;
    __delay_ms(500);

    PORTAbits.RA4   = 1;
    __delay_ms(500);
    PORTAbits.RA5   = 1;
}

und hier die RS232 Teile

#include <stdio.h>
#include <stdlib.h>
#include <math.h>                          
#include <xc.h>                             
#define _XTAL_FREQ 8000000

//*************************************************************************************
// Interrupt Service Routine
// Check uart receive bit and if it is what caused the interrupt, turn LED on and
// read the data from the uart receive buffer.
// Note there is only one ISR to handle all interrupts so you need to determine
// what caused the interrupt before taking action.
//*************************************************************************************
//void interrupt ISR() {
//
//    if (PIR1bits.RCIF)          // see if interrupt caused by incoming data
//    {
//        uart_data = RCREG;     // read the incoming data
//        //IncomingData_LED = 1;   // set LED to indidate byte has been received
//        PIR1bits.RCIF = 0;      // clear interrupt flag
//    }
//}



//*************************************************************************************
// Send one byte via UART
// RB7 = TX
// RB5 = RX
//*************************************************************************************

void uart_xmit(unsigned int mydata_byte) {
//
//            Ausgabe eines Zeichens auf der RS232
//
    while(!TXSTAbits.TRMT);    // make sure buffer full bit is high before transmitting
    TXREG = mydata_byte;       // transmit data
}

void uart_xmit_logo(void) {
//
//            Ausgabe des initialen Logos / Startup Message
//
    uart_xmit('S');                             
    uart_xmit('T');
    uart_xmit('A');
    uart_xmit('R');
    uart_xmit('T');
    uart_xmit(13);                              // CR
    uart_xmit(10);                              // LF
}

und hier die AD Routinen

#include <stdio.h>
#include <stdlib.h>
#include <math.h>                           
#include <xc.h>                             //Use this to include the device header for your PIC.
#define _XTAL_FREQ 8000000

void ADC_format_enable(void) {
//
//    SET Format (Left, Right)
//    Enable AD Converter
//
        ADCON0bits.ADFM = 1;
        ADCON0bits.ADON = 1;
        __delay_ms(10);
}

void ADC_clock_ref () {
//
//      Set ADC Clock and Reference Voltage
//
        ADCON1bits.ADCS = 6;
        ADCON0bits.VCFG = 0;
}

void ADC_SC1_select(unsigned char ADC_channel) {
//
//            Auswählen des AD Kanals
//
//            Kanal 0 = Akkuspannung
            if (ADC_channel == 0) {
                ADCON0bits.CHS0 = 1;                        // Channel Select Bit
                ADCON0bits.CHS1 = 0;                        // Channel Select Bit
                ADCON0bits.CHS2 = 0;                        // Channel Select Bit
                ADCON0bits.CHS3 = 1;                        // Channel Select Bit
            }

//            Kanal 1 = Solar panel
            if (ADC_channel == 1) {
                ADCON0bits.CHS0 = 0;                        // Channel Select Bit
                ADCON0bits.CHS1 = 0;                        // Channel Select Bit
                ADCON0bits.CHS2 = 0;                        // Channel Select Bit
                ADCON0bits.CHS3 = 1;                        // Channel Select Bit
            }

//            Kanal 2 = DC-OUT
             if (ADC_channel == 2) {
                ADCON0bits.CHS0 = 1;                        // Channel Select Bit
                ADCON0bits.CHS1 = 1;                        // Channel Select Bit
                ADCON0bits.CHS2 = 1;                        // Channel Select Bit
                ADCON0bits.CHS3 = 0;                        // Channel Select Bit
            }

//            Kanal 3 = SOLAR #2
            if (ADC_channel == 3) {
                ADCON0bits.CHS0 = 0;                        // Channel Select Bit
                ADCON0bits.CHS1 = 1;                        // Channel Select Bit
                ADCON0bits.CHS2 = 1;                        // Channel Select Bit
                ADCON0bits.CHS3 = 0;                        // Channel Select Bit
            }
//
//            Setze das Ausgabeformat und schalte den ADC ein
//
            ADC_format_enable();
}

float ADC_get_value(unsigned char ADC_channel) {
//
//            Messung des AD Wertes und Rückgabe eines Float Wertes mit 2 Nachkommastellen
//
        int i                       = 0;
        int samples                 = 0;
        long ADC_value              = 0;
        int zahl                    = 0;
        float ADCfloat_wert         = 0;
        float ADC_step              = 0.0048828125;
        float ADC_factor            = 4;


            ADC_SC1_select(ADC_channel);
            PIE1bits.SSPIE          = 0;
            PIE1bits.ADIE           = 0;

//            for (i=0;i<=samples;i++) {
//            while (i <= ADC_samples) {
//            Bevor die Messung stattfindet muss ein Delay eingebaut sein. Das ist
//            notwendig nach einem Channel select
                __delay_ms(5);
//            Das GO_nDONE Bit muss gesetzt werden, danach startet der ADC die Messung
//            Danach solange warten und die Status Bits abfragen
                ADCON0bits.GO_nDONE = 1;                // Start a Conversation
//
//            warte bis im ADCON0 das ADIF gesetzt und Go_nDONE gelöscht ist
//                while ((PIR1bits.ADIF == 0) && (ADCON0bits.GO_nDONE == 1)) {
                while (ADCON0bits.GO_nDONE == 1) {
                    __delay_us(10);
                // nop;
                // warte bis Messung abgeschlossen ist
                }

                //
//            Schalte den AD Converter aus
//
            ADCON0bits.ADON = 0;

//
//            Berechne den gemessenen Wert
//
                ADC_value = (ADC_value + (ADRESL + (ADRESH * 256)));


                //
//        Kalkuliere den Mittelwert der Samples
//        Das Ergebnis muss eine Wert im Bereich int sein (32756)
//
//            ADC_value = (ADC_value / samples);
//            ADC_value       = ADRESL ;
//            ADC_value = (ADC_value + (ADRESL + (ADRESH * 256)));
//
//        Konvertiere die Zahl in einen String
//
//
//        1. Wandle den Messwert in eine Zahl mit genau 2 Nachkommastellen um
//
            ADCfloat_wert = ADC_value * ADC_step * ADC_factor;
            zahl = ADCfloat_wert * 10;
            ADCfloat_wert = zahl / 10.0;

            return(ADCfloat_wert);
//            return(10.1);
}

[castlerock (Gast)]

Unabhängig von deine Kanal-problem (oder auch nicht) ist deine ADC 
benützung etwas unkonventionell.

Standard wäre:
Init:
 I/O pins einstellen.
 ADC einstellen/konfigurieren
 ADC einschalten und an LASSEN.

in main:
 CH selektieren.
 (kurz warten: <100us)
 GO setzen
 auf /DONE warten.
 Werte aus ADRES lesen.


In deine software wird die I/O pins und ADC register überall eingestellt 
bzw. geändert.  Und der ADC wird ständig ein- bzw. ausgeschaltet.
Macht mann normalerweise nicht.  (über deine übermässige benützung von 
delays fange ich am besten nicht an).

Viel glück noch.

[Chris B. (dekatz)]

Das hier in < float ADC_get_value(unsigned char ADC_channel) > macht 
auch wenig Sinn:
>             PIE1bits.SSPIE          = 0;

Wird SPI irgendwo verwendet? Oder sollte an der Stelle etwas anderes 
stehen?

[Georg K. (gkeller)]

Warum macht das keinen / wenig Sinn?
SPI wird nicht verwendet. Ich wollte sicher sein das es def. ist.

[Stephan (Gast)]

dies erklärt nicht warum es ab AN8 nicht geht, Folgendes fällt mir aber 
auf:

1)
Das Pragma FOSC=INTRCIO sollte beim 16F690 lt. Datenblatt eigentlich 
INTOSCIO heißen, oder ist INTRCIO im device file identisch definiert? 
Oer nochmal gefragt: Richtiges device file ausgewählt?

2)
In "Hardware_basic_init" hat die Zuweisung zu OSCCON ein Bit zuviel. Wer 
weiß was das anrichtet...

    OSCCON  = 0b011100000;

Gruß

[X4U (Gast)]

Georg Keller schrieb:
> so ich poste jetzt mal das Programm - zumindest die relevanten Teile:

Da schlage ich ein systematisches herangehen vor, erst einmal 
eingrenzen.

Nimm nur die Teile die du brauchst und probiere es damit.

In Pseudocode:

1. µP konfigurieren
2. A/D konfigurieren
3. Kanal einstellen
4. Wandlung starten
5. Wandlungszeit abwarten.
6. Ergebnis lesen
7. An den Uart senden.

Bei dieser Herangehensweise entsteht über kurz oder lang ein getestetes 
Gerüst der Grundfunktionen. Die erweiterst du dann mit deinen 
Funktionen.

[Georg K. (gkeller)]

Hallo,

hmmm, jetzt habe ich viele Hinweise bekommen und habe wohl erst noch ein 
wenig zu tun mit der Aufarbeitung. Zuerst einmal Danke an alle die sich 
die Zeit genommen haben hier bei meinem Problem zu helfen.

Als Feedback möchte ich noch den Hinweis aus dem Microchip Forum mit 
geben, hier schreibt mir jemand das die IO-PIN Simulation im MPLABx für 
den 16F690 defekt ist - ups. Er hat es auf dem Demo Board nachgestellt 
und hat im Assembler die Ports wie gewünscht ansprechen können. 
http://www.microchip.com/forums/tm.aspx?tree=true&m=866212&mpage=1

Für mich ist es gut und schlecht ;-) Jetzt weiß ich das es vermutlich 
doch geht, weiß auch das ich generell und grundsätzlich nichts falsch 
mache. Schlecht ist, auf meiner HW geht AN8..AN11 nicht, obwohl am Pin 
AN8 die analoge Spannung anliegt.

Vielleicht werde ich es noch mit einem anderen uC testen (16F1829) der 
auch so noch ein paar Vorteile für mein Vorhaben mit sich bringt und 
dann auch die hier angemerkten Punkte in der Software berücksichtigen.

Viele Grüße,
Georg

[X4U (Gast)]

Georg Keller schrieb:
> Als Feedback möchte ich noch den Hinweis aus dem Microchip Forum mit
> geben, hier schreibt mir jemand das die IO-PIN Simulation im MPLABx für
> den 16F690 defekt ist

Wundert mich bei Mplab gar nicht. Die Idee alle Produkte einer Firma 
unter einer Haube zu verwursten halte ich schlicht für falsch.

Nach meiner Erfahrung läuft das z.B. bei MikroE Compilern (bin weder 
verwandt noch verschwägert) deutlich besser. Unter anderem weil da eine 
Produktreihe auch eine IDE hat.

> Vielleicht werde ich es noch mit einem anderen uC testen
Sollten Indizien darauf hinweisen das evtl. Probleme vor dem Monitor 
sitzen könnten ist es besser diese als erstes zu lösen. Zumal der ganze 
Aufbau schon vorhanden ist.

Isoliere das Problem wie oben beschrieben. Wenn es dann immer noch nicht 
funzt liegt es evtl. an was anderem als dem TE. Den Chip gibt es schon 
länger, in den Erratas steht auch nichts in der Richtung und so ein 
Fehler wäre aufgefallen (zumindest jedem außerhalb der MPlAB Abteilung 
bei Microchip).

[Stephan (Gast)]

X4U schrieb:
> Den Chip gibt es schon
> länger, in den Erratas steht auch nichts in der Richtung und so ein
> Fehler wäre aufgefallen

Das sehe ich genauso. Die analogen Ports beim 16f690 funktionieren auch 
anstandslos -habe u.a. in einem Projekt mal AN10 verwendet, kann das 
also grundsätzlich bestätigen.
Auch wenn ich das in Assembler gemacht habe im Prinzip genauso 
konfiguriert wie hier gezeigt.
Ich würde mal vermuten, dass der Fehler irgendwo anders im Quelltext 
steckt, also woanders TRIS oder ANSEL überschrieben wird.

[Georg K. (gkeller)]

Hallo,
ich kann die positive Rückmeldung geben, die Lösung ist gefunden.

Der Controller ist kaputt.

Ich habe einfach einmal auf Verdacht den Chip gewechselt und siehe da 
auf einmal klappt alles. Warum und wieso und was denn nun genau auf dem 
Ding kaputt ist weiß ich nicht aber der neue Baustein tut genau das was 
er soll.

Da haben mir zwei Faktoren aber einen gewaltigen Streich gespielt. Zum 
einen der kaputte Controller und zum anderen der Simulator, der einen 
ähnlichen bug hat.

Dann kann es mit der Programmierung jetzt entsprechend weitergehen. An 
dieser Stelle noch einmal vielen Dank an alle die geholfen haben.

Gruß, Georg

[Jochen-paul S. (picfan)]

hallo
freut mich für Dich, dass es nun geklappt hat. Hatte mit einem anderen 
PIC auch enorm Zeit verloren, bis ich endlich gemerkt hatte dass der 
Simulator von MPPLAB nicht das machte was er sollte.
Falls die Spannungsquelle niederohmig war, die Du mit den drei 
Problem-Eingängen messen wolltest und die PORT's als Ausgänge geschaltet 
waren, hätte dies womöglich die jeweiligen PORT's beschädigt...
freundliche Grüsse Jochen-Paul