'не удалось разрешить идентификатор _delay'

Я продолжаю получать сообщение об ошибке «невозможно разрешить идентификатор _delay». Я использую pic16f1829, MPLAB X IDE v3.26 и в качестве компилятора XC8 v1.41.

Я просто хочу, чтобы на ЖК-дисплее отображались некоторые параметры. Странно то, что я использовал точно такой же код на другом компьютере, загрузил его, и он заработал. Но так как я сменил компьютер (и, возможно, у меня другая версия компилятора и т. д.), он больше не работает. Обычно _delay должна быть встроенной функцией XC8, поэтому я не знаю, почему он жалуется. Я также не уверен, что это причина, по которой ЖК-дисплей не работает, но это единственная ошибка, которую я получаю.

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#include <htc.h>
#include "constants.h"
#include "LCD_code.h"
#include "ShiftRegister_code.h"
#include "ADC_code.h"
#include "Comparator_code.h"


// CONFIG1
#pragma config FOSC = HS    // Oscillator Selection (INTOSC oscillator: I/O function on CLKIN pin)
#pragma config WDTE = OFF        // Watchdog Timer Enable (WDT enabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable (PWRT disabled)
#pragma config MCLRE = ON       // MCLR Pin Function Select (MCLR/VPP pin function is MCLR)
#pragma config CP = OFF         // Flash Program Memory Code Protection (Program memory code protection is disabled)
#pragma config CPD = OFF        // Data Memory Code Protection (Data memory code protection is disabled)
#pragma config BOREN = ON       // Brown-out Reset Enable (Brown-out Reset enabled)
#pragma config CLKOUTEN = ON   // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin)
#pragma config IESO = OFF       // Internal/External Switchover (Internal/External Switchover mode is disabled)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor is disabled)

// CONFIG2
#pragma config WRT = OFF        // Flash Memory Self-Write Protection (Write protection off)
#pragma config PLLEN = OFF       // PLL Enable (4x PLL enabled)
#pragma config STVREN = ON      // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset)
#pragma config BORV = LO        // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.)
#pragma config LVP = OFF        // Low-Voltage Programming Enable (High-voltage on MCLR/VPP must be used for programming)


/**
 * Global variables
 */

// PI parameters
__eeprom unsigned char Igaineeprom;
__eeprom unsigned char Pgaineeprom;
unsigned int Igain=50;//initial value of 300 adaptable with potentiometer
unsigned int Pgain=300;//initial value of 300 adaptable with potentiometer
unsigned int Buttonstatus;
unsigned long Ivalue;

// Voltage
unsigned int Voltage;

// timer parameters
unsigned int timer;
signed int PeriodError;     // error on period

// Algorithm
signed long PIvalue;
signed long IvalueDelta;
signed long Pvalue;
unsigned int PIvaluePos;

// processing
unsigned int Accumulate;
unsigned char write_counter;

//Dumpload shift
unsigned char pos=0;
unsigned char LoadNprevious=0;
unsigned char LoadN=0;


// smart socket
   //unsigned char smartSocketOn;



/**
 * functions
 */
void checkNewCycle();
void PIadapation();
signed long limitRange(signed long, signed long, signed long);


void initialize()
{
    initialize_SR();
    initialize_LCD();
    initializeADC();
    initializeComparator();
}

char byte;

void interrupt ISR(void){
    GIE = 0; // Temporarily stop interrupts
    if (C1IF == 1)
    {
        C1IF = 0;
        checkNewCycle();
    }
    GIE = 1; // Reactivate interrupts
}

/*
 *
 */
int main() {
    initialize();

    LCD_clear();

    for(;;)
    {
        //GIE = 0;
        selectButton(); //Button
        Buttonstatus = readADC();
        if (Buttonstatus==1023){
        selectPot();
        int temp = readADC(); // You don't want P to be minimally 1
        if (temp < 4)
        { Pgain = 0; }
        else
        { Pgain = temp;}
        }
        else {
        selectPot();
        int temp = readADC(); // You don't want I to be minimally 1
        if (temp < 4)
        {
           Igain = 0; }
        else
        { Igain = temp;}
        }
        selectVoltage();
        Voltage = readADC();


        LCD_home();
        LCD_write_string("P: ");
        LCD_write_number_fixed_length(Pgain,4);

        LCD_goto_address(1,9);
        LCD_write_string("I: ");
        LCD_write_number_fixed_length(Igain,4);

        LCD_second_row();
        LCD_write_string("V: ");
        LCD_write_number((Voltage*5)/1000/2.8*220); //Divide by 2.55 because at 2.55V at voltage divider 220V at entry
        LCD_write_string(".");
        LCD_write_number_fixed_length_with_zero(((Voltage*5)/10)%100,2);

        /*
        LCD_goto_address(2,1);
        //LCD_write_number_neg(Ivalue);
        //LCD_write_number_neg(Pvalue);
        LCD_write_number_fixed_length(PIvaluePos,5);
        */

        LCD_goto_address(2,11);
        LCD_write_string("F:");
        long basefreq = 7812500; // Actual base frequency is 781250 Hz
        int frequency = basefreq/timer;

        LCD_write_number_fixed_length(frequency/10,2);
        LCD_write_string(".");
        LCD_write_number(frequency%10);

        for(int i = 0; i<100; i++) {
        _delay(62500); // 0.01 s
        }

        LCD_clear();
        _delay(62500);

    }
}

void checkNewCycle() {
     /**
     * Read Time
     */
    timer = TMR1;      // read the LSB of timer
    TMR1=timer_offset;                   // reset time, heuristic adaptation for lost time

    /**
     * PI berekening
     */
    PeriodError = timer;
    PeriodError = period - PeriodError;     // time difference from wanted

    signed long PE = PeriodError;
    unsigned long PG = Pgain;
    unsigned long IG = Igain;

#   ifdef Imath //The # causes the compiler to add this code only if Imath exists, so only use integrate error if Imath exists

    // I berekening: see figure

    IvalueDelta = PE*IG;
    Ivalue += (IvalueDelta>>10) ;  // Integrate but divide by 1024, order
    Ivalue = limitRange(Ivalue,-1048575,1048575); // Limit to 21bit number
    #else
    Ivalue=0;
    #endif

    // P berekening
    Pvalue = PE*PG;
    Pvalue = limitRange(Pvalue,-1048575,1048575);

    // PI samenstelling
    PIvalue = Ivalue + Pvalue;
    PIvalue = limitRange(PIvalue,-1048575,1048575); // Limit to 21bit number
    PIvalue = PIvalue >> 6;  // Reduce to 15bit number;
    int PItemp = PIvalue;
    PIvaluePos = (PItemp+16384+1); // Let zero action be half the swing (swing goes from -16384 to 16384) (swing=range)
    // Maximum is 32767. Divided by 8 this is: 4095.875
    int NDump = PIvaluePos/4096;
    Accumulate += PIvaluePos%4096;
    if (Accumulate>4096 && NDump!=8){
        NDump+=1;
        Accumulate=0;
    }
    unsigned char LoadN = NDump;




    /**
     * Algoritme voor smartsocket
     */
//            if ((smartSocketOn==1)&&(LoadN==0))
//            {
//                smartSocketOn=0;
//                //LoadN=smartSocket/2;
//            }
//            if ((smartSocketOn==0)&&(LoadN>smartSocket))
//            {
//                smartSocketOn=1;
//                //LoadN=smartSocket/2;
//            }

    /**
     * Convert to loads
     */
/*
    int toLoads;
    switch ( LoadN ) {
        case 0:
            toLoads = 0b00000000;// | smartSocketOn;
            break;
        case 1:
            toLoads = 0b00000010;// | smartSocketOn;
            break;
        case 2:
            toLoads = 0b00000110;// | smartSocketOn;
            break;
        case 3:
            toLoads = 0b00001110;// | smartSocketOn;
            break;
        case 4:
            toLoads = 0b00011110;// | smartSocketOn;
            break;
        case 5:
            toLoads = 0b00111110;// | smartSocketOn;
            break;
        case 6:
            toLoads = 0b01111110;// | smartSocketOn;
            break;
        case 7:
            toLoads = 0b11111110;// | smartSocketOn;
            break;
        case 8:
            toLoads = 0b11111111;// | smartSocketOn;
            break;
        default:
            toLoads = 0b11111111;
            break;
    }
*/


    unsigned char toLoads1 = 0;
    unsigned char toLoads=0;
    unsigned char shift; //shift is new pos
    for(char i=0; i<LoadN; i++)
    {
        toLoads1 += (1 << i);
    }
        if (LoadNprevious>LoadN) {                         // Dumploads off
        shift=pos+(LoadNprevious-LoadN); //new pos
            if (shift>7) {                  // End position array
                shift=shift-8;
            }
            else {
                shift=shift;
            }
    }
         else  {                         // Dumploads on
            shift=pos;
        if (shift>7) {          //UNNECESARY        // End position array
    shift=shift-8;
                    }
            else {
                shift=shift;
            }
    }
    toLoads = (toLoads1 << shift) | (toLoads1 >> (8 - shift));    // Rotate bitpattern left to position


    // write shift register
    putShiftRegister(toLoads);

    //Start calculation of position
    if (LoadNprevious>LoadN) {                 // Dumploads off
        pos+=LoadNprevious-LoadN;
        if (pos>7){
            pos=pos-8;
        }
        else {
            pos=pos;
        }
    }
         else {                         // Dumploads on
    pos=pos;
    }
    //End calculation of position

    LoadNprevious=LoadN;
}



signed long limitRange(signed long number, signed long min, signed long max) {
    if(number>max){
        return max;
    }
    if(number<min) {
        return min;
    }
    return number;
}