HI-TECH PICC 9.82 lỗi khi dịch

Collapse
X
 
  • Giờ
  • Show
Clear All
new posts
  • ducmanh
    Nhập môn đệ tử
    • Sep 2011
    • 2

    #1

    HI-TECH PICC 9.82 lỗi khi dịch

    Xin chào anh em trên diễn đàn , nhờ anh em hướng dẫn thành viên mới.

    em đang sử dụng MPlab IDE v8.70 và HI-TECH PICC 9.82
    để dịch chương trình ứng dụng kiểm tra thiết bị mô hình viết cho 16f883 từ trang


    nhưng bị lỗi sau:

    Executing: "C:\Program Files\HI-TECH Software\PICC\9.82\bin\picc.exe" --pass1 C:\main.c -q --chip=16F883 -P --runtime=default --opt=default -D__DEBUG=1 --rom=default --ram=default -g --asmlist "--errformat=Error [%n] %f; %l.%c %s" "--msgformat=Advisory[%n] %s" "--warnformat=Warning [%n] %f; %l.%c %s"
    Warning [361] C:\main.c; 102.1 function declared implicit int
    Error [192] C:\main.c; 199.1 undefined identifier "RBPU"
    Error [192] C:\main.c; 432.1 undefined identifier "GODONE"
    Warning [361] C:\main.c; 909.1 function declared implicit int

    ********** Build failed! **********


    // man.c
    //----------------------------------

    // Project : E-CHEX

    // PIC16F883 @ 8MHz internal

    // Hi-tech PICC Pro 9.6PL5

    // Last updated : November 17, 2009

    //----------------------------------

    #include <htc.h>

    #include"delay.h"



    // Configuration bit

    // - Use internal RC for Oscillator

    // - Watch-Dog Disabled

    // - Power-up Timer Enabled

    // - Internal reset MCLR pin use as I/O

    // - Internal/External Switchover Disabled because using INTIO

    // - Fail-Safe Clock Monitor Disabled because using INTIO



    __CONFIG(INTIO&WDTDIS&PWRTEN&MCLRDIS&CP&DUNPROTECT &BORDIS&IESODIS&FCMDIS&LVPDIS&DEBUGDIS);

    __CONFIG(BORV21);







    #define Bemf_Rratio 12.02941176

    #define BEC_Rratio 5.7

    #define LiPo_Rratio 11.0

    #define DeadBand 5

    #define T0_Interval 48

    #define NumberOfMode 5

    #define MaxMode NumberOfMode - 1

    #define MaxPole 14



    #define Digit1 RA4 // pin 6

    #define Digit2 RA6 // pin 10

    #define Digit3 RA7 // pin 9



    #define Switch RE3 // Pin 1

    #define RX RB5 // Pin 26

    #define ServoBit RB7 // Pin 28

    #define DotMark 0xF7 // 11110111





    // 7-Segment code commond anode

    const char SegCode[16] = {0x28,0xF9,0x8A,0x98,0x59,0x1C,0x0C,0xF8,0x08,0x18 ,0xFF,0x1E,0xE8,0x8D,0x0E,0xCF};



    volatile char DigitX[3]; // Buffer to store 7-segment code for each digit

    static unsigned char DigitCnt,Debounce,FrameCnt,UpdateDisplayCnt;

    volatile static char Mode;

    static unsigned char StepInc;

    static bit Update,DisplayModeFlag,ssw_flag,TimeSynFlag;

    static unsigned char swState,SweepState,TimeSyn,Mode4State;

    static bit ErrorPulseWidth,ShowPole,ServoEnabled,EnableReadSW ;

    static char Pole;

    unsigned int ppmWidth,NewVal;

    unsigned int Cell[6];

    static unsigned int Mode5Timer;



    volatile static unsigned char ServoVal;



    void Initial_IO(void);

    void DisplayNumber(void);

    void HTO7S(unsigned int Num);

    void HTO7S2(unsigned int Num);

    unsigned int ReadADC(unsigned char ch);

    void TesterMode(void);

    void MeasureMode(void);

    unsigned int ReadPPM(void);

    void ReadSwitch(void);

    void CheckForUpdateDisplay(void);

    void CenterMode(void);

    void SweepMode(void);

    void DisplayBatt(void);

    void DisplayAllCell(unsigned int Volt);

    void DisplayBECVolt(void);

    void DisplayLine(void);

    void KVMode(void);

    unsigned int ReadVR(void);





    //------------------------------------

    // Main program

    //------------------------------------

    main(){



    OSCCON = OSCCON | 0b01110000; // Enable Internal Clock at 8MHz



    ServoEnabled = 0;

    Initial_IO();



    // check to see if ADC4 is Lipo inseted or not(Checking Cell 1 only)

    if ((ReadADC(4) >= 20) && (ReadADC(10) >= 20)){



    DisplayBatt();

    }





    DisplayBECVolt(); // Display BEC voltage





    // Defualt mode is 0 after power on

    // and display Mode Number on 7-segment 1Sec

    DisplayModeFlag = 1;

    DelayBigMs(1000);// Delay for showing Mode "1"

    DisplayModeFlag = 0;



    EnableReadSW = 1; // start to read Switch

    //Mode = 4;

    while(1){

    switch (Mode){

    case 0:{TesterMode();break;}

    case 1:{CenterMode();break;}

    case 2:{SweepMode();break;}

    case 3:{MeasureMode();break;}

    case 4:{KVMode();break;}

    }

    }

    }





    //-------------------------------------------------

    // Interrupt Service Routine

    // Timer 0 interrupt ever 6.667mS

    //-------------------------------------------------

    void interrupt isr(void){



    if (T0IF){

    T0IF=0;

    TMR0 = T0_Interval;

    DisplayNumber(); // Display every 6.667mS

    CheckForUpdateDisplay(); // update display every about 33 mS

    if (EnableReadSW){ ReadSwitch(); }





    //----------------------------------

    // Use in RX measurement mode only

    //----------------------------------

    TimeSyn ++;

    if (TimeSyn>3){

    TimeSyn = 0;

    TimeSynFlag = 1;

    }





    if (ServoEnabled){

    FrameCnt++;

    if (FrameCnt>2){

    FrameCnt=0;



    //Set short timer1

    PR2 = ServoVal - 2;



    // Enable Timer 2.- every Timer 0 interrupt or 20ms = 1 short.

    TMR2 = 0;



    TMR2ON = 1;

    TMR2IF = 0;



    // Do not delete two this lines

    NOP(); // optimize time interval for 0.7mS - 2.3mS

    NOP(); // optimize time interval for 0.7mS - 2.3mS





    ServoBit = 1;

    ssw_flag = 1; // use in sweep mode to syn with servo

    }

    }

    }



    if (TMR2IF){

    TMR2IF = 0;

    TMR2ON = 0;

    ServoBit=0;



    }



    }



    //----------------------------------

    // Initial I/O

    //----------------------------------

    void Initial_IO(void){

    UpdateDisplayCnt = 0;

    Pole = 7;

    ShowPole = 0;

    DigitCnt= 3;

    EnableReadSW = 0;

    Mode = 0;

    swState = 0;

    Update = 0;

    ServoBit = 0;



    // ANS0 for back emf

    // ANS3 for Vdc/2

    // ANS1,ANS2,ANS4-ANS7 for 6 cell lipo

    ANSEL = 0b11111111;



    // ANS9 for BEC

    // ANS11 for VR 10K

    ANSELH = 0b00011111;

    RBPU = 0; // Pull-up on PortB

    WPUB = 0b00100000; // RB5 pull-up for RX pin



    //RE3 = 1;

    //TRISE3 = 1; // Switch



    /*

    TRISA0 = 1; // input for ADC back emf

    TRISA1 = 1; // Cell 6

    TRISA2 = 1; // Cell 5

    TRISA3 = 1; // Vdc/2

    TRISA4 = 0; // Digit 1

    TRISA5 = 1; // Cell 1

    TRISA6 = 0; // Digit 2

    TRISA7 = 0; // Digit 3

    */

    TRISA = 0b00101111;



    PORTC = 0xFF;

    TRISC = 0x00; // PortC as output to control Digit row A to G, except RC7 use for switch



    // RB7 servo, RB6 unused, RB5 RX, RB4 VR, RB3 BEC,

    // RB2 Cell 3 AN8

    // RB1 Cell 2 AN10

    // RB0 Cell 4 AN12

    //PORTB = 0b00110000;

    RB6 = 0;

    TRISB = 0b00111111; //



    ADCON0 = 0b10000001; // AD conversion clock Fosc/32 = 4uS

    ADCON1 = 0b10000000; // Right justified





    T1CON = 0x00;



    T2CON = 0b00100001;

    TMR2IF = 0;

    TMR2IE = 0;



    //-----------------------------------

    // Setup multi tasking

    //-----------------------------------

    T0CS = 0;

    T0SE = 0;

    PSA = 0;

    PS2=1; PS1=0; PS0=1;

    TMR0 = T0_Interval;

    T0IE=1;

    PEIE=1;

    GIE=1;

    }



    //-----------------------------------

    // Display Digit which is called by ISR

    //-----------------------------------

    void DisplayNumber(void){



    if(DisplayModeFlag){

    DigitX[0] = SegCode[Mode+1];// display number of mode(1-4)

    DigitX[1] = SegCode[10]; // display blank

    DigitX[2] = SegCode[10]; // display blank

    }else if (ErrorPulseWidth){

    DigitX[2] = SegCode[14]; // display "E"

    DigitX[1] = SegCode[15]; // display "r"

    DigitX[0] = SegCode[15]; // display "r"

    }else if(ShowPole){

    DigitX[2] = 0x42; // display "P."

    DigitX[1] = SegCode[Pole/10]; // display "0"

    DigitX[0] = SegCode[Pole%10]; // display "0"

    }





    DigitCnt++;

    if (DigitCnt>2){

    DigitCnt=0;

    }



    //Digit1=~Digit1;

    //Digit2=~Digit2;

    //Digit3=0;

    //PORTC=~PORTC;



    //-----------------------------

    // Turn off all digits

    //-----------------------------

    Digit1=0; Digit2=0; Digit3=0;

    PORTC = 0xFF;

    //-----------------------------



    switch(DigitCnt){

    case 0:{PORTC = DigitX[0]; ; Digit1 = 1;break;}

    case 1:{PORTC = DigitX[1]; ; Digit2 = 1;break;}

    case 2:{PORTC = DigitX[2]; ; Digit3 = 1;break;}

    }





    }



    //--------------------------------------

    // Convet HEX 2 byte into 7-Segment code

    // 3 digits x.xx

    //--------------------------------------

    void HTO7S(unsigned int Num){



    unsigned int res;



    DigitX[2]=(SegCode[Num/100] & DotMark);

    res=Num%100;

    DigitX[1]=SegCode[res/10];

    res=res%10;

    DigitX[0]=SegCode[res];





    }



    //--------------------------------------

    // Convet HEX 2 byte into 7-Segment code

    // 3 digits xx.x

    //--------------------------------------

    void HTO7S2(unsigned int Num){



    unsigned int res;



    DigitX[2]=SegCode[Num/100];

    res=Num%100;

    DigitX[1]=SegCode[res/10] & DotMark;

    res=res%10;

    DigitX[0]=SegCode[res];

    }



    //-------------------------------------

    // Display Lipo and A123 Battery

    //-------------------------------------

    void DisplayBatt(void){



    unsigned int V1,V2,V3,V4,V5,V6;



    unsigned int TotalVolt;



    unsigned char i,BattCnt;





    BattCnt=0;





    V1 = ReadADC(4);

    if (V1>20){BattCnt++;}

    V2 = ReadADC(10);

    if (V2>20){BattCnt++;}

    V3 = ReadADC(8);

    if (V3>20){BattCnt++;}

    V4 = ReadADC(12);

    if (V4>20){BattCnt++;}

    V5 = ReadADC(2);

    if (V5>20){BattCnt++;}

    V6 = ReadADC(1);

    if (V6>20){BattCnt++;}



    // display number of cell

    DigitX[2] = SegCode[BattCnt]; // Display number of batt cell

    DigitX[1] = 0xFF; // display "Blank"

    DigitX[0] = 0x1E; // display "C"



    DelayBigMs(1000); // delay 1 second



    DisplayLine(); // display "---"





    while(1){



    V1 = ReadADC(4);

    Cell[0] = V1 - 0;



    V2 = ReadADC(10);

    Cell[1] = V2 - V1;



    V3 = ReadADC(8);

    if (V3>V2){

    Cell[2] = V3 - V2;

    }else{

    Cell[2] = 0;

    }



    V4 = ReadADC(12);

    if(V4>V3){

    Cell[3] = V4 - V3;

    }else{

    Cell[3] = 0;

    }



    V5 = ReadADC(3);

    if (V5>V4){

    Cell[4] = V5 - V4;

    }else{

    Cell[4] = 0;

    }



    V6 = ReadADC(1);

    if (V6>V5){

    Cell[5] = V6 - V5;

    }else{

    Cell[5] = 0;

    }



    for (i=0;i<BattCnt;i++){

    DigitX[0] = SegCode[i+1]; // display number of cell(1-6)

    DigitX[1] = 0x85; // display "o."

    DigitX[2] = 0x68; // display "N"

    DelayBigMs(500);

    HTO7S((unsigned int)(Cell[i] * 0.003225806 * LiPo_Rratio * 100.0));

    DelayBigMs(1000);



    }

    TotalVolt = Cell[0]+Cell[1]+Cell[2]+Cell[3]+Cell[4]+Cell[5];

    DisplayAllCell(TotalVolt);

    }

    }





    //------------------------------------

    // Read ADC

    // return 16th average 10 bit ADC value

    //------------------------------------

    unsigned int ReadADC(unsigned char ch){



    unsigned char i;

    unsigned int ADC;



    ADCON0 = ((ADCON0 & 0b11000011) | (ch << 2));

    NOP();NOP();NOP();NOP();NOP();



    ADC = 0;

    for (i=0;i<16;i++){

    GODONE = 1;

    while(GODONE) continue; // wait for conversion complete

    ADC = ADC + ((ADRESH<<8) | ADRESL);

    }



    return (ADC>>4);

    }





    //--------------------------------------

    // Read Pulse Width

    // return : Pulse width 0.5mS - 2.5mS

    // : 0 if pulse high or low > 2.5mS

    //

    // Actual Standard Pulse is 1mS - 2mS

    //

    //--------------------------------------

    unsigned int ReadPPM(void){



    TimeSyn = 0;

    TimeSynFlag = 0;



    while(!TimeSynFlag) continue;

    TimeSynFlag = 0;



    while(RX){

    if (TimeSynFlag){

    return 0;

    }

    }



    //-----------------------------------------------

    // Timer prescaler 1:1

    // Fosc/4 = 0.5uS

    // Timer 1 will count from

    // EC78 to FFFF

    // So time interval for counting is

    // FFFFh - EC78h + 1 = 1388h

    // or

    // 65535 - 60536 + 1 = 5000

    // 5000 * (prescaler 1:1) * 0.5uS = 2500uS = 2.5mS

    //-------------------------------------------------

    TMR1H = 0xEC;

    TMR1L = 0x78;

    TMR1ON = 1;



    // wait high pulse

    while(!RX){

    if (TimeSynFlag){

    return 0;

    }

    }





    NOP();NOP();

    while(RX){

    if (TimeSynFlag){

    return 0;

    }

    }



    return ((((TMR1H<<8) | TMR1L) - 0xEC78) >> 1) ;





    }



    //------------------------------------

    // Read Switch for changing mode

    //------------------------------------

    void ReadSwitch(void){



    if (swState==0){

    if (!Switch){

    swState=1;

    Debounce=0;

    }

    }else if(swState==1){

    Debounce++;

    if (Debounce>1){

    if (!Switch){

    DisplayModeFlag=1;

    swState=2;

    Debounce=0;

    }else{

    swState=0;

    }

    }

    }else if(swState==2){

    if (Switch){ // check to see switch released or not

    swState=3; // Yes switch released goto next state

    Debounce=0;

    }else{

    Debounce++;

    if (Debounce>150){

    Debounce=0;

    if (Mode==4){

    if (!Switch){

    DisplayModeFlag=0;

    ShowPole = 1;

    swState=6;

    }

    }

    }

    }

    }else if(swState==3){

    Debounce++; // debounce when switch released

    if (Debounce>1){

    Debounce=0;

    swState=4;

    }

    }else if(swState==4){ // checking switch pressed again or not in 1 Sec

    Debounce++;

    if (Debounce>150){

    DisplayModeFlag=0;

    Debounce=0;

    swState=0;



    }else if(!Switch){

    swState=5;

    Debounce=0;

    }

    }else if(swState==5){

    Debounce++;

    if (Debounce>1){

    if (!Switch){

    Mode++;

    if (Mode>MaxMode){Mode=0;}

    swState = 2;



    }else{

    swState=0;

    }

    }

    }



    //------------------------------------

    // Use in Mode 4(KVM mode only)

    //------------------------------------

    else if(swState==6){

    if (Switch){

    Debounce = 0;

    swState = 7;

    }

    }else if(swState==7){ // delay switch after switch released

    Debounce++;

    if (Debounce>2){

    Mode5Timer = 0;

    swState = 8;

    }

    //------------------------------------

    }else if(swState==8){

    Mode5Timer++;

    if (Mode5Timer>300){

    DisplayModeFlag=0;

    ShowPole = 0;

    swState = 0;

    }else if (!Switch){

    Debounce = 0;

    swState = 9;

    }



    }else if(swState==9){

    Debounce++;

    if (Debounce>2){

    Debounce = 0;

    if (!Switch){

    Pole++;

    if (Pole>=(MaxPole+1)){

    Pole = 1;

    }

    Mode5Timer = 0;

    swState = 10;

    }else{

    swState = 8;

    }

    }

    }else if(swState==10){

    if (Switch){

    Debounce = 0;

    swState = 11;

    }

    }else if(swState==11){

    Debounce++;

    if (Debounce>2){

    swState = 8;

    }

    }



    }



    //--------------------------------------

    // Check before update display every 100mS

    // Use on Tester Mode and Measure Mode only

    //--------------------------------------

    void CheckForUpdateDisplay(void){

    UpdateDisplayCnt++;

    if (UpdateDisplayCnt>15){

    UpdateDisplayCnt = 0;

    Update = 1;

    }

    }







    //---------------------------------------

    // Display All Cell of Batt

    //---------------------------------------

    void DisplayAllCell(unsigned int Volt){



    DigitX[0] = 0x2F; // Display "L"

    DigitX[1] = 0x2F; // display "L"

    DigitX[2] = 0x48; // display "A"

    DelayBigMs(500);



    HTO7S2((unsigned int)(Volt * 0.003225806 * LiPo_Rratio * 10.0));

    DelayBigMs(1000);



    }





    //---------------------------------------

    // Display "---"

    //---------------------------------------

    void DisplayLine(void){

    DigitX[0] = 0xDF; // Display "-"

    DigitX[1] = 0xDF; // display "-"

    DigitX[2] = 0xDF; // display "-"

    DelayBigMs(1000);

    }



    //------------------------------------

    // Read VR

    //------------------------------------

    unsigned int ReadVR(void){

    return (ReadADC(11);

    }





    //--------------------------------------

    // Display BEC after power on in test mode

    //--------------------------------------

    void DisplayBECVolt(void){



    DigitX[0] = 0x2E; // Display "C"

    DigitX[1] = 0x0E; // display "E"

    DigitX[2] = 0x0D; // display "b"

    DelayBigMs(1000);



    HTO7S((unsigned int)(ReadADC(9) * 0.003225806 * BEC_Rratio * 100.0));

    DelayBigMs(1000);



    DisplayLine();



    }





    //------------------------------------

    // Servo Tester Manual Mode

    // Send pulse with 0.7mS - 2.3mS to servo

    // Mode : 1

    //------------------------------------

    void TesterMode(void){



    while(DisplayModeFlag) continue;

    FrameCnt = 0;

    ServoEnabled = 1;

    TMR2IE = 1;

    while(Mode==0){



    // scale ADC value to Pulse width 700uS - 2300uS

    // NewVal = ReadADC()/[(1023.0)/(2300.0-700.0))] + 700.0;

    // ReadADC()

    // -------------- + 700

    // (1023 - 0)

    // ----------

    // (2300-700)

    //NewVal = (unsigned int)(ReadVR()*1.56402737) + 700; // Vcc 3.3V

    NewVal = (unsigned int)(ReadVR()*1.56555773) + 700; // Vcc 3.25V



    if (NewVal>2300){ NewVal = 2300;}



    ServoVal = NewVal/10;

    //ServoVal =70;



    if (Update){

    Update = 0;

    HTO7S(ServoVal); // display can show only 3 digits, so last digit cutted by divide by 10

    }

    }

    ServoEnabled = 0;

    }



    //--------------------------------------

    // Center Mode

    // Mode : 2

    //--------------------------------------

    void CenterMode(void){

    unsigned int VRPos;



    while(DisplayModeFlag) continue;

    FrameCnt = 0;

    ServoEnabled = 1;

    TMR2IE = 1;

    ServoVal = 150;

    while(Mode==1){



    VRPos = ReadVR(); // VR return 0-1023 ,so half is 511.5

    if (VRPos<=500){

    ServoVal = 150;

    }else if (VRPos>=521){

    ServoVal = 152;

    }



    if (Update){

    HTO7S(ServoVal); // display can show only 3 digits, so last digit cutted by divide by 10

    Update = 0;

    }

    }



    ServoEnabled = 0;

    }



    //-------------------------------------

    // Sweep Mode

    // Mode : 3

    //-------------------------------------

    void SweepMode(void){

    unsigned char DelayStop;



    while(DisplayModeFlag) continue;

    FrameCnt = 0;

    ServoEnabled = 1;

    TMR2IE = 1;



    //ServoVal = 70;

    //DelayMs(100);



    SweepState=0;



    while(Mode==2){



    if (ssw_flag){

    ssw_flag=0;



    StepInc = (unsigned char)((ReadVR()/((1023.0)/(9.0)))) + 1; // scale ADC value to 1-10

    if(SweepState==0){

    ServoVal = ServoVal + StepInc;

    if (ServoVal>230){

    ServoVal = 230;

    SweepState=1;

    DelayStop = 0;

    }

    }else if (SweepState==1){

    DelayStop++;

    if (DelayStop>15){

    SweepState=2;

    }

    }else if (SweepState==2){

    ServoVal = ServoVal - StepInc;

    if (ServoVal<70){

    ServoVal = 70;

    SweepState=3;

    DelayStop = 0;

    }

    }else if (SweepState==3){

    DelayStop++;

    if (DelayStop>15){

    SweepState=0;

    }

    }

    }



    if (Update){

    HTO7S(ServoVal); // display can show only 3 digits, so last digit cutted by divide by 10

    Update = 0;

    }

    }

    ServoEnabled = 0;

    }







    //------------------------------------

    // Measure Mode

    // Pulse width 0.7mS - 2.3mS is OK

    // Display : Err if pulse are not in range

    //

    // Option (just option no need in this version)

    // display "U-x" if pulse under 0.7mS

    // display "O-x" if pulse over 2.3ms

    // when x is error code

    // Mode : 4

    //------------------------------------

    void MeasureMode(void){



    ServoEnabled = 0;

    T1CON = 0b11000000;

    T1GSS = 1;

    while(Mode==3){

    ppmWidth = ReadPPM() ;

    if (ppmWidth==0){

    ErrorPulseWidth = 1; // Error caused by High or low too long(>2.5mS)

    }else if ((ppmWidth>=700) && (ppmWidth<=2300)){

    ErrorPulseWidth =0;

    }

    if (Update){

    Update = 0;

    HTO7S(ppmWidth/10); // display can show only 3 digits, so last digit cutted by divide by 10

    }

    }

    ErrorPulseWidth =0;

    T1CON = 0x00;

    T1GSS = 0;

    }





    //--------------------------------------

    // KV Measurement mode

    // Use measuere Back EMF method

    // Send pulse 1mS - 2mS to ESC

    // Error < +/-5%

    // Input : P Magnet Pole Pairs enter by user

    // : Back EMF by measuring

    // : Vdc by measuring

    // Mode 5

    //--------------------------------------

    void KVMode(void){

    unsigned int KVmotor, MecRPM, Bemf, Vdc;

    unsigned int Ton, Toff, Ttotal, TCnt;

    float FMecRPM, FBemf, FVdc;



    while(DisplayModeFlag) continue;



    ServoVal = 70;

    FrameCnt = 0;

    ServoEnabled = 1;



    DelayBigMs(300);

    Mode4State = 0;





    // Comparator 1 on, Internal output, Non-invert, referrence form C1IN+ pin(Vdc/2)

    // C12IN0- pin of C1 connects to C1VIN-

    CM2CON0 = 0b00000000;



    T1GSS = 0; // Timer1 gate source is SYNCC2OUT

    C2SYNC = 1; // Output is synchronous to falling edge of Timer1 clock



    // Timer 1

    // Prescaler 1:8 TMR1L = 00-FF or 0 - 1mS (256 * 8 * 0.5uS ~ 1mS)

    // So max frequency about 1kHz = 1/1mS

    // Count Fosc/4 when gate high

    //

    T1CON = 0b11100001;

    MecRPM = 0;

    Bemf = 0;

    KVmotor = 0;

    Vdc = 0;



    C2IE = 0; // disable comparator 2 intterupt

    C2ON = 1; // Comparator 2 on



    while(Mode==4){

    //------------------------------------

    // Checking for update display

    //------------------------------------

    if (Update){

    Update = 0;

    //HTO7S(MecRPM);

    //HTO7S(Bemf);

    HTO7S(KVmotor);

    //HTO7S(Vdc);

    }



    if (Mode4State==0){

    if (ReadVR()<10){

    Mode4State=1;

    DelayMs(100);

    }

    }else if (Mode4State==1){ // Measure pulse high



    // scale 0 - 3.25V to 1mS - 2mS

    NewVal = (unsigned int)((ReadVR() * 0.978473581) + 1000); // Vcc 3.25V

    if (NewVal>2000){ NewVal = 2000;}

    ServoVal = NewVal/10;



    if (ServoVal>=199){

    Mode4State=2;

    Ton = 0;

    Toff = 0;

    TCnt = 0;

    }

    }else if (Mode4State==2){

    C2POL = 0;

    for (TCnt=0;TCnt<16;TCnt++){

    while(!TimeSynFlag) continue;



    TimeSynFlag = 0;

    while(C2OUT){

    if (TimeSynFlag){

    break;

    }

    }





    TMR1H = 0;

    TMR1L = 0;

    TMR1ON = 1;

    // wait high pulse

    while(!C2OUT){

    if (TimeSynFlag){

    break;

    }

    }



    NOP();NOP();

    while(C2OUT){

    if (TimeSynFlag){

    break;

    }

    }





    Ton = Ton + ((TMR1H<<8) | TMR1L);

    }

    Ton = Ton>>4;

    Mode4State=3;



    }else if (Mode4State==3){ // Measure pulse low

    C2POL = 1;

    for (TCnt=0;TCnt<16;TCnt++){

    while(!TimeSynFlag) continue;



    TimeSynFlag = 0;

    while(C2OUT){

    if (TimeSynFlag){

    break;

    }

    }



    TMR1H = 0;

    TMR1L = 0;

    TMR1ON = 1;

    // wait high pulse

    while(!C2OUT){

    if (TimeSynFlag){

    break;

    }

    }



    NOP();NOP();

    while(C2OUT){

    if (TimeSynFlag){

    break;

    }

    }



    Toff = Toff + ((TMR1H<<8) | TMR1L);

    }

    Mode4State=4;



    }else if (Mode4State==4){ // Measure pulse low

    C2POL = 0;

    Bemf = 0;

    for (TCnt=0;TCnt<16;TCnt++){

    while(!TimeSynFlag) continue;

    TimeSynFlag = 0;

    while(C2OUT){

    if (TimeSynFlag){

    break;

    }

    }

    NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();

    Bemf = Bemf + ReadADC(0);

    }



    Bemf = Bemf>>4;



    //------------------------------------------------------------------------------

    // FZero period is Ttotal = Ttotal * 2

    //

    // FZero = 1 = 500000

    // -------------------- -------- Hz

    // Ttotal * 4 * 0.5uS Ttotal

    //

    // When Ttotal = Ton + Toff

    //

    //

    // 500000 60

    // Mechanical rpm = -------- * ----------- (RPM)

    // Ttotal Pole Pairs

    //

    //

    // 30000000

    // Mechanical rpm = --------------------

    // Ttotal * Pole Pairs

    //

    // But Actual Ttotal of FZero obtained by

    // Ttotal = 2 * Ttotal

    // So new Mechanical rpm is

    //

    // 30000000 15000000

    // Mechanical rpm = ------------------------ = ----------------------

    // 2 * Ttotal * Pole Pairs Ttotal * Pole Pairs

    //--------------------------------------------------------------------



    //--------------------------------------------------------------------

    // MecRPM

    // KVmotor = ------

    // Bemf

    //

    // 15000000

    // = -------------------

    // Ttotal * Pole Pairs

    // --------------------------------------

    // ReadADC(0) * 0.003225806 * 12.02941176

    //

    // 2

    // Actual Bemf = --- * Measured Bemf

    // 3

    // = 0.6666666 * Measured Bemf(average measured voltage at coil terminal)

    //----------------------------------------------------------------------



    //Bemf = (unsigned int)(ReadADC(0) * 0.003225806 * BemfRratio * 100.0); // for display

    //Vdc = (unsigned int)(((ReadADC(2) * 0.003225806 * 23.72727273)/ 2.0) * 100.0); // for display

    //MecRPM = (unsigned int)(15000000.0/(Ttotal * Pole * 10.0)); // for display





    Ttotal = Ton + (Toff>>4); // This is period for 360 eletric degree for FZero

    FBemf = Bemf * 0.003225806 * Bemf_Rratio * (2.0/3.0);

    //FVdc = (unsigned int)(((ReadADC(2) * 0.003225806 * 23.72727273)/ 2.0) + 0.3);

    FMecRPM = 15000000.0/(Ttotal * Pole);

    KVmotor = (unsigned int)(FMecRPM/FBemf)/10;





    Mode4State=1;

    }



    }

    C2ON = 0;

    ServoEnabled = 0;

    }
  • caokeu260691
    Nhập môn đệ tử
    • Dec 2011
    • 3

    #2
    Ban co the cho mjnh duong dan de de dowload trinh duyet hitech c dc ko?

    Comment

    Working...