#include "p30f2020.

h"

_FOSCSEL(PRIOSC_PLL) // This sets up the device for use with external

Crystal in PLL MODE
_FOSC(CSW_FSCM_OFF & HS)
_FWDT(FWDTEN_OFF)
_FBS(BWRP_WRPROTECT_ON)
_FGS(CODE_PROT_OFF)
// This sets the Oscillator Source
// This turns the Watchdog timer off
// Boot Segment is Write Protected
//Code Protection is OFF

// Define Global Variables

struct pidParameters
{
float Kp;
float Ki;
float Kd;

signed long int error;

signed long int output;
signed long int outmax;
signed long int ReferenceSetpoint;
signed long int feedback;
signed long int integral;
signed long int derivitive;
signed long int previous_error;
signed long int saturated;
} pidParams;

void setup(void) // Funtion definition for setup of the ADC AND Power PWM Module.
{

PTCONbits.PTEN = 0; // This will disable the PWM Module

PTPER = 15992; // Sets the PWM Period to 16.667u secs (60KHz Switching
Frequency)Period Duration = (PTPER + 1) / 120MHz.

/* Initialize PWM Generator 1 */

IOCON1bits.PENH = 1; // PWM Module controls High output

IOCON1bits.PENL = 1; // PWM Module controls Low output
IOCON1bits.POLH = 0; // High Output Polarity is active High
IOCON1bits.POLL = 0; // Low Output Polarity is active High
IOCON1bits.PMOD = 1; // Independant output mode
IOCON1bits.OVRENH = 0; // High Output Override disabled
IOCON1bits.OVRENL = 0; // Low Output Override disabled

PWMCON1bits.FLTSTAT = 0; // Clear Fault Interrupt flag

PWMCON1bits.CLSTAT = 0;
PWMCON1bits.TRGSTAT = 0;
PWMCON1bits.FLTIEN = 0;
PWMCON1bits.CLIEN = 0;
PWMCON1bits.TRGIEN = 0;
PWMCON1bits.ITB = 0;
PWMCON1bits.MDCS = 0;
PWMCON1bits.DTC = 2;
PWMCON1bits.XPRES = 0;
PWMCON1bits.IUE = 0;
// Clear Current Limit Interrupt flag
// Clear PWM Trigger Interrupt flag
// Disable Fault Interrupt
// Disable Current Limit Interrupt
// Disable Trigger Interrupt
// Time base is read from PTMR
// Duty cycle is read from PDC
// No Dead Time
// No extenal reset for PTMR
// Immediate update to PDC
 TRGCON1bits.TRGDIV = 2;
usecs between successive interations with the system
TRGCON1bits.TRGSTRT = 0;
TRIG1 = 15992;
PDC1 = 0;
PHASE1 = 0;
FCLCON1 = 0x0003;
PTCON = 0x8000;
/* Initialize the ADC */
ADCONbits.ADSIDL = 0;
ADCONbits.FORM = 0;
ADCONbits.EIE = 1;
ADCONbits.ORDER = 0;
ADCONbits.SEQSAMP = 1;
ADCONbits.ADCS = 4;
ADSTAT = 0;
ADPCFG = 0xFFC0;
inputs
ADCPC0bits.TRGSRC0 = 0x4;
PWM#1 Trigger
ADCPC0bits.IRQEN0 = 1;
ADCONbits.ADON = 1;
/* Set up the Interrupts */
IFS0bits.ADIF = 0;
IPC2bits.ADIP = 4;
IEC0bits.ADIE = 1;
int main(void)
pidParams.Kp = 0.4;
pidParams.Ki = 0;
pidParams.Kd = 0;
pidParams.outmax = 15992;
frequency
PTPER) / 100
pidParams.ReferenceSetpoint = 707; //Corresponds to 14.5Volts
pidParams.feedback = 0;
pidParams.integral = 0;
pidParams.derivitive = 0;
// Trigger on every 3rd event. That is 50
// Start the counting at the start
// Trigger event at 16.667 usec from
// start of the PWM cycle
// Initially start with with a 0% Duty Cycle
// No staggering
// Fault Input is disabled
// Enable PWM Module
// Operate in Idle Mode
// Output in Integer Format
// Enable Early Interrupt
// Even channel first
// Sequential Sampling Enabled
// Clock Divider is set up for Fadc/12
// Clear the ADSTAT register
// AN0/AN1, AN2/AN3, AN4/AN5 are analog
// Trigger conversion OF CHANNELS AN0/AN1 on
// Enable the interrupt
// Start the ADC module
// Clear AD Interrupt Flag
// ADC Interrupt Priority Is Set To 1
// Enable the ADC Interrupt
// The Maximum PWM Value is a function of
// Max Duty = (Percent *
 pidParams.previous_error = 0;

setup(); // Function Call to setup peripherals

while(1)
{
}
}

// Interrupt Service Routine will read ADC and Update the Duty Cycle Register
// The ISR is Invoked at a 20KHz rate. This 50usecs between updates of the Duty
Cycle Register.

void __attribute__((__interrupt__)) _ADCInterrupt()

{

TRISE = 0xffCf; //Set LED pins E4 and E5 as outputs

LATEbits.LATE5 = 1; // Turn LED ON

IFS0bits.ADIF = 0; // Clear ADC Interrupt Flag

ADSTATbits.P0RDY = 0; // Clear the ADSTAT bits
pidParams.feedback = ADCBUF0; // Get the conversion result
from channel AN0

pidParams.error = pidParams.ReferenceSetpoint - pidParams.feedback; //

This claculated the proportional error

if ((pidParams.error > 2) || (pidParams.error < -2)) // If error is within 2

then do not do the PID Calculation.
{

if (pidParams.saturated == 0) // If the PID controller is

staurated the flag will be 1 and no
// accumulation of
integral/derivitive will be done.
{
if (pidParams.integral < 32000)

{
if (pidParams.integral > -32000)
pidParams.integral += pidParams.error;
}

pidParams.derivitive = pidParams.error -
pidParams.previous_error;

// NOW WE EXECUTE THE ACTUAL PID ALGORITHM

pidParams.output =(pidParams.Kp * pidParams.error

+ pidParams.Ki * pidParams.integral
+ pidParams.Kd * pidParams.derivitive);

// Perform boundary checks on the output of the PID algorithm. If the output limits
are exceeded then, then set output to the limit
// and set flag.

if (pidParams.output > pidParams.outmax)

{
pidParams.saturated = 1;
pidParams.output = pidParams.outmax;
}

else if (pidParams.output < 0)

{
pidParams.saturated = 1;
pidParams.output = 0;
}
else
pidParams.saturated = 0;

pidParams.previous_error = pidParams.error;

PDC1 = pidParams.output; // Update the duty cycle

register

LATEbits.LATE5 = 0;// Turn the LED OFF

}
}