PIC16F690 AN8 bis AN11 nicht nutzbar

/*

 * 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);

}

#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;

}

#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

}

#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);

}