TMS320F28377S: eQEP , encoder for tms320f28377s

Hi SWAPNIL,

Are you starting with our C2000Ware examples? We have several examples calculating the speed measurment in RPM. The examples can be found within our C2000Ware SDK located at C:\ti\c2000\C2000Ware_x_xx_xx_xx\device_support\f2837xs\examples\cpu1\eqep_pos_speed\cpu01\Eqep_pos_speed.c

Please refer to these for the GPIO setup.

Best,

Ryan Ma

Thanks for the reply Ryan Ma,

I have tried the eqep_posspeed example by making changes according to my requirements the program is even getting build but still no outputs although I have removed the EPWM part as I don't need to simulate the signals.I have posted the code can you please take a look and get back to me

//
#include "F28x_Project.h"
#include "Example_posspeed.h"
int samplingtime = 100;
//

//
// Globals
//
POSSPEED qep_posspeed=POSSPEED_DEFAULTS;
Uint16 Interrupt_Count = 0;

//
// Function Prototypes
//
//void initEpwm();
interrupt void TIMER1_ISR(void);

//
// Main
//
void main(void)
{
//
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the F2837xS_SysCtrl.c file.
//
InitSysCtrl();

//
// Step 2. Initialize GPIO:
// This example function is found in the F2837xS_Gpio.c file and
// illustrates how to set the GPIO to its default state.
//
// InitGpio(); // Skipped for this example

//
// For this case only init GPIO for eQEP1 and ePWM1
// This function is found in F2837xS_EQep.c
//
InitEQep1Gpio();
// InitEPwm1Gpio();
EALLOW;
GpioCtrlRegs.GPADIR.bit.GPIO4 = 1; // GPIO4 as output simulates Index signal
GpioDataRegs.GPACLEAR.bit.GPIO4 = 1; // Normally low
EDIS;

//
// Step 3. Clear all __interrupts and initialize PIE vector table:
// Disable CPU __interrupts
//
DINT;

//
// Initialize the PIE control registers to their default state.
// The default state is all PIE __interrupts disabled and flags
// are cleared.
// This function is found in the F2837xS_PieCtrl.c file.
//
InitPieCtrl();

//
// Disable CPU __interrupts and clear all CPU __interrupt flags:
//
IER = 0x0000;
IFR = 0x0000;

//
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the __interrupt
// is not used in this example. This is useful for debug purposes.
// The shell ISR routines are found in F2837xS_DefaultIsr.c.
// This function is found in F2837xS_PieVect.c.
//
InitPieVectTable();

//
// Interrupts that are used in this example are re-mapped to
// ISR functions found within this file.
//
EALLOW; // This is needed to write to EALLOW protected registers
PieVectTable.TIMER1_INT = &TIMER1_ISR;
EDIS; // This is needed to disable write to EALLOW protected registers
InitCpuTimers();
ConfigCpuTimer(&CpuTimer1,200,samplingtime);
CpuTimer1Regs.TCR.all = 0x4000;
//
// Step 4. Initialize all the Device Peripherals:
//
//initEpwm(); // This function exists in Example_EPwmSetup.c

//
// Step 5. User specific code, enable __interrupts:
// Enable CPU INT1 which is connected to CPU-Timer 0:
//
IER |= M_INT3;

//
// Enable TINT0 in the PIE: Group 3 __interrupt 1
//
PieCtrlRegs.PIEIER3.bit.INTx1 = 1;

//
// Enable global Interrupts and higher priority real-time debug events:
//
EINT; // Enable Global __interrupt INTM
ERTM; // Enable Global realtime __interrupt DBGM

qep_posspeed.init(&qep_posspeed);

for(;;)
{
}
}
void InitEQep1Gpio()
{

GpioCtrlRegs.GPAPUD.bit.GPIO20 = 0; // Enable pullup on GPIO20
GpioCtrlRegs.GPAPUD.bit.GPIO21 = 0; // Enable pullup on GPIO21
GpioCtrlRegs.GPAPUD.bit.GPIO22 = 0; // Enable pullup on GPIO22
GpioCtrlRegs.GPAPUD.bit.GPIO23 = 0; // Enable pullup on GPIO23
GpioCtrlRegs.GPAQSEL2.bit.GPIO20 = 0; // Synch to SYSCLKOUT
GpioCtrlRegs.GPAQSEL2.bit.GPIO21 = 0; // Synch to SYSCLKOUT
GpioCtrlRegs.GPAQSEL2.bit.GPIO22 = 0; // Synch to SYSCLKOUT
GpioCtrlRegs.GPAQSEL2.bit.GPIO23 = 0; // Synch to SYSCLKOUT
GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 1; // GPIO20 = EQEP1A
GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 1; // GPIO21 = EQEP1B
GpioCtrlRegs.GPAMUX2.bit.GPIO22 = 1; // GPIO22 = EQEP1S
GpioCtrlRegs.GPAMUX2.bit.GPIO23 = 1; // GPIO23 = EQEP1I
EDIS;
}

//
// prdTick - EPWM1 Interrupts once every 4 QCLK counts (one period)
//
void POSSPEED_Init(void)
{
EQep1Regs.QUPRD = 2000000; // Unit Timer for 100Hz at 200 MHz
// SYSCLKOUT
EQep1Regs.QDECCTL.bit.QSRC = 00; // QEP quadrature count mode
EQep1Regs.QEPCTL.bit.FREE_SOFT = 2;
EQep1Regs.QEPCTL.bit.PCRM = 00; // PCRM=00 mode - QPOSCNT reset on
// index event
EQep1Regs.QEPCTL.bit.UTE = 1; // Unit Timeout Enable
EQep1Regs.QEPCTL.bit.QCLM = 1; // Latch on unit time out
EQep1Regs.QPOSMAX = 0xffffffff;
EQep1Regs.QEPCTL.bit.QPEN = 1; // QEP enable
EQep1Regs.QCAPCTL.bit.UPPS = 5; // 1/32 for unit position
EQep1Regs.QCAPCTL.bit.CCPS = 6; // 1/64 for CAP clock
EQep1Regs.QCAPCTL.bit.CEN = 1; // QEP Capture Enable
}

//
// POSSPEED_Calc - Perform the position calculations
//
void POSSPEED_Calc(POSSPEED *p)
{
long tmp;
unsigned int pos16bval;
_iq Tmp1,newp,oldp;

//
// Position calculation - mechanical and electrical motor angle
//
p->DirectionQep = EQep1Regs.QEPSTS.bit.QDF; // Motor direction:
// 0=CCW/reverse, 1=CW/forward

pos16bval = (unsigned int)EQep1Regs.QPOSCNT; // capture position once
// per QA/QB period
p->theta_raw = pos16bval+ p->cal_angle; // raw theta = current pos. +
// ang. offset from QA

//
// The following lines calculate
// p->theta_mech ~= QPOSCNT/mech_scaler [current cnt/(total cnt in 1 rev.)]
// where mech_scaler = 4000 cnts/revolution
//
tmp = (long)((long)p->theta_raw*(long)p->mech_scaler); // Q0*Q26 = Q26
tmp &= 0x03FFF000;
p->theta_mech = (int)(tmp>>11); // Q26 -> Q15
p->theta_mech &= 0x7FFF;

//
// The following lines calculate p->elec_mech
//
p->theta_elec = p->pole_pairs*p->theta_mech; // Q0*Q15 = Q15
p->theta_elec &= 0x7FFF;

//
// Check an index occurrence
//
if(EQep1Regs.QFLG.bit.IEL == 1)
{
p->index_sync_flag = 0x00F0;
EQep1Regs.QCLR.bit.IEL = 1; // Clear __interrupt flag
}

//
// High Speed Calculation using QEP Position counter
//
// Check unit Time out-event for speed calculation:
// Unit Timer is configured for 100Hz in INIT function
//
if(EQep1Regs.QFLG.bit.UTO == 1) // If unit timeout (one 100Hz period)
{
//
// Differentiator
//
// The following lines calculate
// position = (x2-x1)/4000 (position in 1 revolution)
//
pos16bval = (unsigned int)EQep1Regs.QPOSLAT; // Latched POSCNT value
tmp = (long)((long)pos16bval*(long)p->mech_scaler); // Q0*Q26 = Q26
tmp &= 0x03FFF000;
tmp = (int)(tmp>>11); // Q26 -> Q15
tmp &= 0x7FFF;
newp = _IQ15toIQ(tmp);
oldp = p->oldpos;

if(p->DirectionQep==0) // POSCNT is counting down
{
if(newp>oldp)
{
Tmp1 = - (_IQ(1) - newp + oldp); // x2-x1 should be negative
}
else
{
Tmp1 = newp -oldp;
}
}
else if(p->DirectionQep == 1) // POSCNT is counting up
{
if(newp<oldp)
{
Tmp1 = _IQ(1) + newp - oldp;
}
else
{
Tmp1 = newp - oldp; // x2-x1 should be positive
}
}

if(Tmp1>_IQ(1))
{
p->Speed_fr = _IQ(1);
}
else if(Tmp1<_IQ(-1))
{
p->Speed_fr = _IQ(-1);
}
else
{
p->Speed_fr = Tmp1;
}

//
// Update the electrical angle
//
p->oldpos = newp;

//
// Change motor speed from pu value to rpm value (Q15 -> Q0)
// Q0 = Q0*GLOBAL_Q => _IQXmpy(), X = GLOBAL_Q
//
p->SpeedRpm_fr = _IQmpy(p->BaseRpm,p->Speed_fr);

EQep1Regs.QCLR.bit.UTO=1; // Clear __interrupt flag
}

//
// Low-speed computation using QEP capture counter
//
// if(EQep1Regs.QEPSTS.bit.UPEVNT == 1) // Unit position event
// {
// if(EQep1Regs.QEPSTS.bit.COEF == 0) // No Capture overflow
// {
// temp1 = (unsigned long)EQep1Regs.QCPRDLAT; // temp1 = t2-t1
// }
// else // Capture overflow, saturate the result
// {
// temp1 = 0xFFFF;
// }
//
// //
// // p->Speed_pr = p->SpeedScaler/temp1
// //
// p->Speed_pr = _IQdiv(p->SpeedScaler,temp1);
// Tmp1 = p->Speed_pr;
//
// if (Tmp1>_IQ(1))
// {
// p->Speed_pr = _IQ(1);
// }
// else
// {
// p->Speed_pr = Tmp1;
// }
//
// //
// // Convert p->Speed_pr to RPM
// //
// if(p->DirectionQep == 0) // Reverse direction = negative
// {
// //
// // Q0 = Q0*GLOBAL_Q => _IQXmpy(), X = GLOBAL_Q
// //
// p->SpeedRpm_pr = -_IQmpy(p->BaseRpm,p->Speed_pr);
// }
// else // Forward direction = positive
// {
// //
// // Q0 = Q0*GLOBAL_Q => _IQXmpy(), X = GLOBAL_Q
// //
// p->SpeedRpm_pr = _IQmpy(p->BaseRpm,p->Speed_pr);
// }

EQep1Regs.QEPSTS.all = 0x88; // Clear Unit position event flag
// Clear overflow error flag

}

interrupt void TIMER1_ISR(void)
{ PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
Uint16 i;

//
// Position and Speed measurement
//
qep_posspeed.calc(&qep_posspeed);

//
// Control loop code for position control & Speed control
//
Interrupt_Count++;

//
// Every 1000 __interrupts(4000 QCLK counts or 1 rev.)
//
if (Interrupt_Count==1000)
{
EALLOW;
GpioDataRegs.GPASET.bit.GPIO4 = 1; // Pulse Index signal (1 pulse/rev.)
for (i=0; i<700; i++)
{
}
GpioDataRegs.GPACLEAR.bit.GPIO4 = 1;
Interrupt_Count = 0; // Reset count
EDIS;
}

//
// Acknowledge this __interrupt to receive more __interrupts from group 1
//

// EPwm1Regs.ETCLR.bit.INT=1;
}

Does the example work as expected for you? Does the ePWM simulated signals work with the eQEP? If that works then there must be some issue with the input signals coming into your GPIOs.

If the example works, instead of passing in the EPWM signals to the eQEP inputs, can you connect your signals to the same GPIOs?

Best,

Ryan Ma