seklyuts/MotorControlModuleSDFM_TMS320F28388D
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity

Настроен контур тока, добавлены алгоритмы обработки СКВТ через ацп

Browse Source
This commit is contained in:
Eugene 2023-10-12 08:47:43 +03:00
parent 2926985867
commit 1ffbe89ef4
24 changed files with 1071 additions and 491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Diakont Datashets/EXT_MEM/LY61L102416A.PDF Normal file
View File

Binary file not shown.

BIN
Diakont Datashets/EXT_MEM/MX29LV160DBTI.pdf Normal file
View File

Binary file not shown.

2
Projects/epwm_test/2838x_FLASH_lnk_cpu1.cmd
View File

@ -74,7 +74,7 @@ SECTIONS
#if defined(__TI_EABI__)
.init_array : > FLASH1, ALIGN(8)
.bss : > RAMGS0
.bss : > RAMGS0 // instead of RAMLS5
.bss:output : > RAMLS3
.bss:cio : > RAMLS5
.data : > RAMLS5

BIN
Projects/epwm_test/Start_rfm.pmp
View File

Binary file not shown.

3
Projects/epwm_test/epwm_test.c
View File

@ -7,7 +7,8 @@
//
//###########################################################################
//
// in 2838x_FLASH_lnk_cpu1.cmd
// .bss : > RAMGS0 // instead of RAMLS5
//###########################################################################
//

24
Projects/epwm_test/lib/f2838x_epwm.c
View File

@ -403,31 +403,31 @@ void InitEPwm11Gpio(void)
// power consumption. Pull-ups can be enabled or disabled by the user.
// Comment out other unwanted lines.
//
GpioCtrlRegs.GPFPUD.bit.GPIO165 = 1; // Disable pull-up on GPIO165 (EPWM11A)
GpioCtrlRegs.GPFPUD.bit.GPIO166 = 1; // Disable pull-up on GPIO166 (EPWM11B)
// GpioCtrlRegs.GPAPUD.bit.GPIO20 = 1; // Disable pull-up on GPIO20 (EPWM11A)
// GpioCtrlRegs.GPAPUD.bit.GPIO21 = 1; // Disable pull-up on GPIO21 (EPWM11B)
// GpioCtrlRegs.GPFPUD.bit.GPIO165 = 1; // Disable pull-up on GPIO165 (EPWM11A)
// GpioCtrlRegs.GPFPUD.bit.GPIO166 = 1; // Disable pull-up on GPIO166 (EPWM11B)
GpioCtrlRegs.GPAPUD.bit.GPIO20 = 1; // Disable pull-up on GPIO20 (EPWM11A)
GpioCtrlRegs.GPAPUD.bit.GPIO21 = 1; // Disable pull-up on GPIO21 (EPWM11B)
//
// Configure EPWM-11 pins using GPIO regs. This specifies which of the
// possible GPIO pins will be EPWM11 functional pins.
// Comment out other unwanted lines.
//
GpioCtrlRegs.GPFMUX1.bit.GPIO165 = 1; // Configure GPIO165 as EPWM11A
GpioCtrlRegs.GPFMUX1.bit.GPIO166 = 1; // Configure GPIO166 as EPWM11B
// GpioCtrlRegs.GPFMUX1.bit.GPIO165 = 1; // Configure GPIO165 as EPWM11A
// GpioCtrlRegs.GPFMUX1.bit.GPIO166 = 1; // Configure GPIO166 as EPWM11B
// //
// // Alternate mapping for EPWM-11. Uncomment if required. Write 0 to
// // GPAMUx register before configuring GPAGMux to avoid glitches.
// //
// GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0; // Configure GPAMUX to 0 for GPIO20
// GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0; // Configure GPAMUX to 0 for GPIO21
GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0; // Configure GPAMUX to 0 for GPIO20
GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0; // Configure GPAMUX to 0 for GPIO21
//
// GpioCtrlRegs.GPAGMUX2.bit.GPIO20 = 1; // Configure GPAGMUX for EPWM11A
// GpioCtrlRegs.GPAGMUX2.bit.GPIO21 = 1; // Configure GPAGMUX for EPWM11B
GpioCtrlRegs.GPAGMUX2.bit.GPIO20 = 1; // Configure GPAGMUX for EPWM11A
GpioCtrlRegs.GPAGMUX2.bit.GPIO21 = 1; // Configure GPAGMUX for EPWM11B
//
// GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 1; // Configure GPAMUX for EPWM11A
// GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 1; // Configure GPAMUX for EPWM11B
GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 1; // Configure GPAMUX for EPWM11A
GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 1; // Configure GPAMUX for EPWM11B
EDIS;
}

17
Projects/epwm_test/src/ExternalEEPROM/ExtEEPROM.c
View File

@ -5,6 +5,7 @@
* Author: seklyuts
*/
#include "f28x_project.h"
#include "i2c_init.h"
#include "BL25CM1A.h"
#include "GD25Q16ETIGR.h"
#include "ZD24C02A.h"
@ -12,20 +13,19 @@
#define MAX_BUFFER_SIZE 0x10
uint16_t sendNowI2C = 0, sendNowSPIGD25 = 0, sendNowSPIBL25 = 0;
uint16_t TestADR = 0;
uint16_t NByte = 16;
uint16_t WriteI2C = 0;
uint16_t Adr = 0;
uint16_t Adr = 0x0;
uint32_t SpiAdr = 0;
uint16_t ArrayForTests[MAX_BUFFER_SIZE] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10};
uint16_t ArrayForTests[MAX_BUFFER_SIZE+1] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x51, 0x52};
uint16_t ArrayMax[256];
void ExtEEPROM_run(void)
{
if(sendNowI2C)
if(sendNowI2C==1)
{
if(WriteI2C)
{
@ -34,11 +34,16 @@ void ExtEEPROM_run(void)
}
else
{
ArrayForTests[0] = Adr;
ZD24C02A_read(NByte, ArrayForTests);
ArrayMax[0] = Adr;
ZD24C02A_read(NByte, ArrayMax);
}
sendNowI2C = 0;
}
else if(sendNowI2C==2)
{
I2CWriteRes();
sendNowI2C = 0;
}
switch(sendNowSPIGD25)
{

106
Projects/epwm_test/src/Peripherals/gpio_init.c
View File

@ -9,33 +9,109 @@
void GpioInit(void)
{
EALLOW;
GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO20 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO21 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO20 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO21 = 1;
GpioDataRegs.GPADAT.bit.GPIO20 = 0;
GpioDataRegs.GPADAT.bit.GPIO21 = 0;
// GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0;
// GpioCtrlRegs.GPAGMUX2.bit.GPIO20 = 0;
// GpioCtrlRegs.GPADIR.bit.GPIO20 = 1;
// GpioDataRegs.GPADAT.bit.GPIO20 = 0;
//
// GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0;
// GpioCtrlRegs.GPAGMUX2.bit.GPIO21 = 0;
// GpioCtrlRegs.GPADIR.bit.GPIO21 = 1;
// GpioDataRegs.GPADAT.bit.GPIO21 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO18 = 0;
GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 0;
GpioCtrlRegs.GPAGMUX1.bit.GPIO15 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO15 = 1;
GpioDataRegs.GPADAT.bit.GPIO15 = 0;
GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 0;
GpioCtrlRegs.GPBGMUX2.bit.GPIO54 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO54 = 1;
GpioDataRegs.GPBDAT.bit.GPIO54 = 0;
GpioCtrlRegs.GPBMUX2.bit.GPIO55 = 0;
GpioCtrlRegs.GPBGMUX2.bit.GPIO55 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO55 = 1;
GpioDataRegs.GPBDAT.bit.GPIO55 = 0;
GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 0;
GpioCtrlRegs.GPBGMUX2.bit.GPIO56 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO56 = 1;
GpioDataRegs.GPBDAT.bit.GPIO56 = 0;
GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 0;
GpioCtrlRegs.GPBGMUX2.bit.GPIO57 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO57 = 1;
GpioDataRegs.GPBDAT.bit.GPIO57 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO18 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO18 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO19 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0;
GpioCtrlRegs.GPAGMUX2.bit.GPIO19 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO19 = 0;
GpioCtrlRegs.GPCMUX2.bit.GPIO90 = 0;
GpioCtrlRegs.GPCGMUX2.bit.GPIO90 = 0;
GpioCtrlRegs.GPCDIR.bit.GPIO90 = 0;
GpioCtrlRegs.GPCMUX2.bit.GPIO92 = 0;
GpioCtrlRegs.GPCGMUX2.bit.GPIO92 = 0;
GpioCtrlRegs.GPCDIR.bit.GPIO92 = 0;
GpioCtrlRegs.GPCMUX2.bit.GPIO94 = 0;
GpioCtrlRegs.GPCGMUX2.bit.GPIO94 = 0;
GpioCtrlRegs.GPCDIR.bit.GPIO94 = 0;
GpioCtrlRegs.GPDMUX2.bit.GPIO127 = 0;
GpioCtrlRegs.GPDGMUX2.bit.GPIO127 = 0;
GpioCtrlRegs.GPDDIR.bit.GPIO127 = 0;
GpioCtrlRegs.GPEMUX2.bit.GPIO147 = 0;
GpioCtrlRegs.GPEGMUX2.bit.GPIO147 = 0;
GpioCtrlRegs.GPEDIR.bit.GPIO147 = 0;
GpioCtrlRegs.GPDMUX1.bit.GPIO104 = 0;
GpioCtrlRegs.GPDGMUX1.bit.GPIO104 = 0;
GpioCtrlRegs.GPDDIR.bit.GPIO104 = 0;
EDIS;
}
void Gpio20out(uint16_t out_bit)
//void Gpio20out(uint16_t out_bit)
//{
// GpioDataRegs.GPADAT.bit.GPIO20 = out_bit;
//}
//
//void Gpio21out(uint16_t out_bit)
//{
// GpioDataRegs.GPADAT.bit.GPIO21 = out_bit;
//}
void Gpio15out(uint16_t out_bit)
{
GpioDataRegs.GPADAT.bit.GPIO20 = out_bit;
GpioDataRegs.GPADAT.bit.GPIO15 = out_bit;
}
void Gpio21out(uint16_t out_bit)
void Gpio54out(uint16_t out_bit)
{
GpioDataRegs.GPADAT.bit.GPIO21 = out_bit;
GpioDataRegs.GPBDAT.bit.GPIO54 = out_bit;
}
void Gpio55out(uint16_t out_bit)
{
GpioDataRegs.GPBDAT.bit.GPIO55 = out_bit;
}
void Gpio56out(uint16_t out_bit)
{
GpioDataRegs.GPBDAT.bit.GPIO56 = out_bit;
}
void Gpio57out(uint16_t out_bit)
{
GpioDataRegs.GPBDAT.bit.GPIO57 = out_bit;
}

16
Projects/epwm_test/src/Peripherals/gpio_init.h
View File

@ -9,8 +9,20 @@
#define SRC_GPIO_INIT_H_
#define FaultAL !GpioDataRegs.GPCDAT.bit.GPIO90
#define FaultAH !GpioDataRegs.GPCDAT.bit.GPIO92
#define FaultBL !GpioDataRegs.GPCDAT.bit.GPIO94
#define FaultBH !GpioDataRegs.GPDDAT.bit.GPIO127
#define FaultCL !GpioDataRegs.GPEDAT.bit.GPIO147
#define FaultCH !GpioDataRegs.GPDDAT.bit.GPIO104
void GpioInit(void);
void Gpio20out(uint16_t out_bit);
void Gpio21out(uint16_t out_bit);
//void Gpio20out(uint16_t out_bit);
//void Gpio21out(uint16_t out_bit);
void Gpio15out(uint16_t out_bit);
void Gpio54out(uint16_t out_bit);
void Gpio55out(uint16_t out_bit);
void Gpio56out(uint16_t out_bit);
void Gpio57out(uint16_t out_bit);
#endif /* SRC_GPIO_INIT_H_ */

263
Projects/epwm_test/src/Peripherals/i2c_init.c
View File

@ -22,7 +22,7 @@
#define TIME_OVER 1000
uint16_t TimerTimeouts = 0, ErrI2c = 0, ErrI2c1 = 0, ErrI2c2 = 0, ErrI2c3 = 0, Addr=0, Addr1[255];
uint16_t TimerTimeouts = 0, ErrI2c = 0, ErrI2c1 = 0, ErrI2c2 = 0, ErrI2c3 = 0, Addr1[255];
uint16_t RXdata, addrCount=0;
void TimerBaseTimeoutInc(void)
@ -92,7 +92,7 @@ void I2CMasterInit(uint16_t I2C_OwnAddress, uint16_t I2CSlave_Address)
I2caRegs.I2CSTR.all = 0xFFFF;
//
// Enable I2C Interrupts- RRDY
// I2C Interrupts
//
I2caRegs.I2CIER.all = 0x08;
@ -100,36 +100,32 @@ void I2CMasterInit(uint16_t I2C_OwnAddress, uint16_t I2CSlave_Address)
// Take I2C out of reset
//
I2caRegs.I2CMDR.all |= 0x0020;
EDIS;
}
void I2CWriteRes(void)
{
I2caRegs.I2CSAR.all = 0xFF;
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x0;
I2caRegs.I2CCNT = 0;
I2caRegs.I2CMDR.bit.STT = 0x1;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
I2caRegs.I2CMDR.bit.STP = 0x1;
TimerTimeouts = 0;
while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c1++;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
I2caRegs.I2CMDR.bit.STP = 0x1;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
}
uint16_t j = 0;
//
// Function to send data over I2C.
//
void I2CWrite(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition, uint16_t * I2C_TXdata)
{
uint16_t index = 0;
I2caRegs.I2CSAR.all = slaveAddr; // Slave address
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x1;
I2caRegs.I2CCNT = byteCount;
for(index=0; index < byteCount; index++)
{
I2caRegs.I2CDXR.all= I2C_TXdata[index];
}
if(sendStopCondition) I2caRegs.I2CMDR.bit.STP = 0x1;
I2caRegs.I2CMDR.bit.STT = 0x1;
}
void I2CWrite1(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition, uint16_t * I2C_TXdata)
{
//
@ -170,12 +166,9 @@ void I2CWrite1(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition, u
//
TimerTimeouts = 0;
while((I2caRegs.I2CSTR.bit.BYTESENT != 0x1)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c++;
// else {Addr1[addrCount] = slaveAddr; addrCount++; if(addrCount > 255) addrCount = 0;}
//
//clear the byte sent
//
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
if(TimerTimeouts >= TIME_OVER) {ErrI2c++; return;}
}
//
@ -186,8 +179,8 @@ void I2CWrite1(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition, u
I2caRegs.I2CMDR.bit.STP = 0x1;
TimerTimeouts = 0;
while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c1++;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
if(TimerTimeouts >= TIME_OVER) {ErrI2c1++; return;}
}
}
@ -222,217 +215,29 @@ uint16_t I2CRead(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition,
TimerTimeouts = 0;
while((count < (byteCount))&&(TimerTimeouts < TIME_OVER))
{
if(count == (byteCount-1)) {I2caRegs.I2CMDR.bit.NACKMOD = 0x1; I2caRegs.I2CMDR.bit.STP = 0x1;}
// if(count == (byteCount-1)) {I2caRegs.I2CMDR.bit.NACKMOD = 0x1; I2caRegs.I2CMDR.bit.STP = 0x1;}
if(I2caRegs.I2CSTR.bit.RRDY ==0x1)
{
RXdata = I2C_RXdata[count-1] = I2caRegs.I2CDRR.all;
RXdata = I2C_RXdata[count] = I2caRegs.I2CDRR.all;
count++;
}
}
if(TimerTimeouts >= TIME_OVER) ErrI2c2 += (byteCount - count);
if(TimerTimeouts >= TIME_OVER) {ErrI2c2 += (byteCount - count); return 0;}
//
// Send STOP condition
//
// if(sendStopCondition)
// {
// I2caRegs.I2CMDR.bit.STP = 0x1;
// TimerTimeouts = 0;
// while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
// if(TimerTimeouts >= TIME_OVER) ErrI2c3++;
// I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
// }
if(sendStopCondition)
{
I2caRegs.I2CMDR.bit.STP = 0x1;
TimerTimeouts = 0;
while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
if(TimerTimeouts >= TIME_OVER) {ErrI2c3++; return 0;}
}
return count;
}
uint16_t I2CWriteRead(uint16_t slaveAddr, uint16_t byteCount, bool sendStopCondition, uint16_t * I2C_RXdata)
{
//
// Locals
//
//
// Configure slave address
//
I2caRegs.I2CSAR.all = slaveAddr; // Slave address
//
// Configure I2C as Master Transmitter
//
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x1;
//
//Set Data Count
//
I2caRegs.I2CCNT = 1;
//
// send Start condition
//
I2caRegs.I2CMDR.bit.STT = 0x1;
//
//transmit the bytes
//
I2caRegs.I2CDXR.all= I2C_RXdata[0];
//
//wait till byte is sent
//
TimerTimeouts = 0;
while((I2caRegs.I2CSTR.bit.BYTESENT != 0x1)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c++;
else Addr = slaveAddr;
//
//clear the byte sent
//
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
//
// Configure slave address
//
I2caRegs.I2CSAR.all = slaveAddr;
//
// Configure I2C in Master Receiver mode
//
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x0;
//
//Set Data Count
//
I2caRegs.I2CCNT = byteCount;
//
// send Start condition
//
I2caRegs.I2CMDR.bit.STP = 0x1;
I2caRegs.I2CMDR.bit.STT = 0x1;
uint16_t count = 0;
//
// Read the received data into RX buffer
//
TimerTimeouts = 0;
while((count < byteCount)&&(TimerTimeouts < TIME_OVER))
{
if(count == (byteCount-1)) I2caRegs.I2CMDR.bit.NACKMOD = 0x1;
if(I2caRegs.I2CSTR.bit.RRDY ==0x1)
{
I2C_RXdata[count] = I2caRegs.I2CDRR.all;
count++;
}
}
if(TimerTimeouts >= TIME_OVER) ErrI2c2 += (byteCount - count);
//
// Send STOP condition
//
if(sendStopCondition)
{
I2caRegs.I2CMDR.bit.STP = 0x1;
TimerTimeouts = 0;
while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c3++;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
}
return count;
}
void I2CWriteReadOnes(uint16_t slaveAddr)
{
//
// Locals
//
//
// Configure slave address
//
I2caRegs.I2CSAR.all = slaveAddr; // Slave address
//
// Configure I2C as Master Transmitter
//
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x1;
//
//Set Data Count
//
I2caRegs.I2CCNT = 1;
//
// send Start condition
//
I2caRegs.I2CMDR.bit.STT = 0x1;
//
//transmit the bytes
//
I2caRegs.I2CDXR.all= 0x80;
//
//wait till byte is sent
//
TimerTimeouts = 0;
while((I2caRegs.I2CSTR.bit.BYTESENT != 0x1)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c++;
else Addr = slaveAddr;
//
//clear the byte sent
//
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
//
// Configure slave address
//
I2caRegs.I2CSAR.all = slaveAddr;
//
// Configure I2C in Master Receiver mode
//
I2caRegs.I2CMDR.bit.MST = 0x1;
I2caRegs.I2CMDR.bit.TRX = 0x0;
//
//Set Data Count
//
I2caRegs.I2CCNT = 0;
//
// send Start condition
//
I2caRegs.I2CMDR.bit.STT = 0x1;
//
// Read the received data into RX buffer
//
TimerTimeouts = 0;
I2caRegs.I2CMDR.bit.NACKMOD = 0x1;
while((I2caRegs.I2CSTR.bit.RRDY != 0x1)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c2++;
else RXdata = I2caRegs.I2CDRR.all;
I2caRegs.I2CMDR.bit.NACKMOD = 0x1;
//
// Send STOP condition
//
I2caRegs.I2CMDR.bit.STP = 0x1;
TimerTimeouts = 0;
while((I2caRegs.I2CMDR.bit.STP != 0x0)&&(TimerTimeouts < TIME_OVER));
if(TimerTimeouts >= TIME_OVER) ErrI2c3++;
I2caRegs.I2CSTR.bit.BYTESENT = 0x1;
}

1
Projects/epwm_test/src/Peripherals/i2c_init.h
View File

@ -24,5 +24,6 @@ void I2CMasterGpioInit(void);
void TimerBaseTimeoutInc(void);
void I2CWriteReadOnes(uint16_t slaveAddr);
void I2CWriteOnse(uint16_t slaveAddr);
void I2CWriteRes(void);
#endif /* SRC_PERIPHERALS_I2C_INIT_H_ */

118
Projects/epwm_test/src/Peripherals/pwm_init.c
View File

@ -21,36 +21,32 @@ volatile uint16_t PwmBrake100 = PERIOD_BRAKE;
volatile uint16_t PwmMotor100 = PERIOD_MOTOR;
void pwm_AutoChange(uint16_t Num)
{
if(EPwm_DB_Direction[Num] == COUNT_UP)
{
if(EPwmRegs[Num]->CMPA.bit.CMPA < PWM_MAX)
{
EPwmRegs[Num]->CMPA.bit.CMPA++;
}
else
{
EPwm_DB_Direction[Num] = COUNT_DOWN;
EPwmRegs[Num]->CMPA.bit.CMPA--;
}
}
else
{
if(EPwmRegs[Num]->CMPA.bit.CMPA <= PWM_MIN)
{
EPwm_DB_Direction[Num] = COUNT_UP;
EPwmRegs[Num]->CMPA.bit.CMPA++;
}
else
{
EPwmRegs[Num]->CMPA.bit.CMPA--;
}
}
EPwmTimerIntCount[Num]++;
void PWM_ABC_StopAllClose(void)
{
EALLOW;
EPwm2Regs.TZCTL.bit.TZA = 2;
EPwm2Regs.TZCTL.bit.TZB = 2;
EPwm3Regs.TZCTL.bit.TZA = 2;
EPwm3Regs.TZCTL.bit.TZB = 2;
EPwm4Regs.TZCTL.bit.TZA = 2;
EPwm4Regs.TZCTL.bit.TZB = 2;
EDIS;
}
void PWM_ABC_StartOut(void)
{
EALLOW;
EPwm2Regs.TZCTL.bit.TZA = 3;
EPwm2Regs.TZCTL.bit.TZB = 3;
EPwm3Regs.TZCTL.bit.TZA = 3;
EPwm3Regs.TZCTL.bit.TZB = 3;
EPwm4Regs.TZCTL.bit.TZA = 3;
EPwm4Regs.TZCTL.bit.TZB = 3;
EDIS;
}
void PWMAllInit(void)
{
@ -70,8 +66,28 @@ void PWMAllInit(void)
PWMInit(3, PwmMotor100, COMPLIMENTARY);
PWMInit(4, PwmMotor100, COMPLIMENTARY);
PWMInit(5, PwmBrake100, INDEPENDED);
PWMInit(6, PwmBrake100, INDEPENDED);
// PWMInit(11, PERIOD, INDEPENDED);
PWMInit(6, PwmMotor100, COMPLIMENTARY);
PWMInit(11, PwmMotor100, INDEPENDED);
PWMInit(12, PwmMotor100, INDEPENDED);
EPwm11Regs.CMPC = SDFM_DELAY;
EPwm11Regs.CMPD = SDFM_DELAY;
EPwm12Regs.CMPC = SDFM_DELAY;
EPwm12Regs.CMPD = SDFM_DELAY;
EPwm11Regs.CMPA.bit.CMPA = SDFM_DELAY;
EPwm11Regs.CMPB.bit.CMPB = SDFM_DELAY;
EPwm12Regs.CMPA.bit.CMPA = SDFM_DELAY;
EPwm12Regs.CMPB.bit.CMPB = SDFM_DELAY;
EALLOW;
EPwm2Regs.TZCTL.bit.TZA = 2;
EPwm2Regs.TZCTL.bit.TZB = 2;
EPwm3Regs.TZCTL.bit.TZA = 2;
EPwm3Regs.TZCTL.bit.TZB = 2;
EPwm4Regs.TZCTL.bit.TZA = 2;
EPwm4Regs.TZCTL.bit.TZB = 2;
EDIS;
EALLOW;
CpuSysRegs.PCLKCR0.bit.TBCLKSYNC =1;
@ -86,6 +102,7 @@ void PWMGpioInit(void)
InitEPwm4Gpio();
InitEPwm5Gpio();
InitEPwm6Gpio();
InitEPwm11Gpio();
}
void PWMInitEnable(void)
@ -110,6 +127,7 @@ void PWMInitInterruptEn(void)
PieVectTable.EPWM4_INT = &epwm4_isr;
PieVectTable.EPWM5_INT = &epwm5_isr;
PieVectTable.EPWM6_INT = &epwm6_isr;
PieVectTable.EPWM11_INT = &epwm11_isr;
EDIS; // This is needed to disable write to EALLOW protected registers
@ -118,28 +136,31 @@ void PWMInitInterruptEn(void)
IER |= M_INT3;
//
// Enable EPWM INTn in the PIE: Group 3 interrupt 1-3
// Enable EPWM INTn in the PIE: Group 3 interrupt 1-3 (page 150)
//
// PieCtrlRegs.PIEIER3.bit.INTx1 = 1;
PieCtrlRegs.PIEIER3.bit.INTx2 = 1;
// PieCtrlRegs.PIEIER3.bit.INTx3 = 1;
// PieCtrlRegs.PIEIER3.bit.INTx4 = 1;
PieCtrlRegs.PIEIER3.bit.INTx5 = 1;
// PieCtrlRegs.PIEIER3.bit.INTx6 = 1;
PieCtrlRegs.PIEIER3.bit.INTx6 = 1;
PieCtrlRegs.PIEIER3.bit.INTx11 = 1;
}
void PWMInit(uint16_t Num, uint16_t Period, uint16_t Independed)
{
EPwmRegs[Num]->TBPRD = Period; // Set timer period
if( (Num < 11)||(Num > 12) ) EPwmRegs[Num]->TBPRD = Period;
else EPwmRegs[Num]->TBPRD = Period*2-1;// Set timer period
EPwmRegs[Num]->TBPHS.bit.TBPHS = 0x0000; // Phase is 0
EPwmRegs[Num]->TBCTR = 0x0000; // Clear counter
//
// Setup TBCLK
//
EPwmRegs[Num]->TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN;
if( (Num < 11)||(Num > 12) ) EPwmRegs[Num]->TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN;
else EPwmRegs[Num]->TBCTL.bit.CTRMODE = TB_COUNT_UP;
EPwmRegs[Num]->TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase loading
EPwmRegs[Num]->TBCTL.bit.HSPCLKDIV = TB_DIV1; // Clock ratio to SYSCLKOUT
EPwmRegs[Num]->TBCTL.bit.CLKDIV = TB_DIV1;
@ -152,17 +173,30 @@ void PWMInit(uint16_t Num, uint16_t Period, uint16_t Independed)
//
// Setup compare
//
EALLOW;
EPwmRegs[Num]->TZCTL.bit.TZA = 3;
EPwmRegs[Num]->TZCTL.bit.TZB = 3;
EPwmRegs[Num]->TZFRC.all = 4;
EDIS; //Ïðîãðàììíî âûñòàâëÿåì TZ-ñîáûòèå
//
// Set actions
//
EPwmRegs[Num]->AQCTLA.bit.CAU = AQ_SET; // Set PWM1A on Zero
EPwmRegs[Num]->AQCTLA.bit.CAD = AQ_CLEAR;
EPwmRegs[Num]->AQCTLB.bit.CAU = AQ_CLEAR; // Set PWM1A on Zero
EPwmRegs[Num]->AQCTLB.bit.CAD = AQ_SET;
if( (Num < 11)||(Num > 12) )
{
EPwmRegs[Num]->AQCTLA.bit.CAU = AQ_SET; // Set PWM1A on Zero
EPwmRegs[Num]->AQCTLA.bit.CAD = AQ_CLEAR;
EPwmRegs[Num]->AQCTLB.bit.CAU = AQ_CLEAR; // Set PWM1A on Zero
EPwmRegs[Num]->AQCTLB.bit.CAD = AQ_SET;
}
else
{
EPwmRegs[Num]->AQCTLA.bit.ZRO = AQ_SET;
EPwmRegs[Num]->AQCTLA.bit.CAU = AQ_CLEAR;
EPwmRegs[Num]->AQCTLB.bit.ZRO = AQ_SET;
EPwmRegs[Num]->AQCTLB.bit.CBU = AQ_CLEAR;
}
//
// Active Low PWMs - Setup Deadband
//
@ -187,7 +221,9 @@ void PWMInit(uint16_t Num, uint16_t Period, uint16_t Independed)
//
//
EPwmRegs[Num]->ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero event
if( (Num < 11)||(Num > 12) ) EPwmRegs[Num]->ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero event
else EPwmRegs[Num]->ETSEL.bit.INTSEL = ET_CTRU_CMPA;
EPwmRegs[Num]->ETSEL.bit.INTEN = 1; // Enable INT
EPwmRegs[Num]->ETPS.bit.INTPRD = ET_1ST; // Generate INT on 1 event
}

26
Projects/epwm_test/src/Peripherals/pwm_init.h
View File

@ -1,5 +1,5 @@
/*
* init.h
* pwm_init.h
*
* Created on: 21 àâã. 2023 ã.
* Author: seklyuts
@ -9,21 +9,24 @@
#ifndef SRC_PWM_INIT_H_
#define SRC_PWM_INIT_H_
#define SYS_PWM_FREQUENCY 100000000.0 //Hz
#define SYS_PWM_FREQUENCY 100000000.0 //Hz
#define FREQUENCY_BRAKE 200000.0 //Hz
#define FREQUENCY_MOTOR 10000.0 //Hz
#define EPWM_DB_mkS 3.0 //mkS
#define FREQUENCY_BRAKE 200000.0 //Hz
#define FREQUENCY_MOTOR 10000.0 //Hz
#define EPWM_DB_mkS 3.0 //mkS
#define PERIOD_BRAKE (SYS_PWM_FREQUENCY/2/FREQUENCY_BRAKE) //Tic
#define PERIOD_MOTOR (SYS_PWM_FREQUENCY/2/FREQUENCY_MOTOR) //Tic
#define PERIOD_BRAKE (SYS_PWM_FREQUENCY/2/FREQUENCY_BRAKE) //Tic
#define PERIOD_MOTOR (SYS_PWM_FREQUENCY/2/FREQUENCY_MOTOR) //Tic
#define EPWM_DB (EPWM_DB_mkS*SYS_PWM_FREQUENCY/2/1000000)
#define EPWM_DB (EPWM_DB_mkS*SYS_PWM_FREQUENCY/1000000)
#define SDFM_DELAY_mkS 48.0 //mkS
#define SDFM_DELAY (SDFM_DELAY_mkS*SYS_PWM_FREQUENCY/1000000)
#define PERIOD_2 (PERIOD_MOTOR/2)
#define PWM_MAX (PERIOD_MOTOR - EPWM_DB)
#define PWM_MIN EPWM_DB
#define PWM_MIN EPWM_DB*2
#define INDEPENDED 1
#define COMPLIMENTARY 0
@ -33,6 +36,9 @@ void PWMGpioInit(void);
void PWMInitEnable(void);
void PWMInitInterruptEn(void);
void PWMAllInit(void);
void PWM_ABC_StopAllClose(void);
void PWM_ABC_StartOut(void);
void InitEPwm1Example(void);
void InitEPwm2Example(void);
@ -41,7 +47,7 @@ void InitEPwm4Example(void);
void InitEPwm5Example(void);
void InitEPwm6Example(void);
void pwm_AutoChange(uint16_t Num);
#endif /* SRC_PWM_INIT_H_ */

170
Projects/epwm_test/src/Peripherals/pwm_interrupts.c
View File

@ -7,19 +7,22 @@
#include <pwm_init.h>
#include "f28x_project.h"
#include"frm_uart.h"
#include "frm_uart.h"
#include "gpio_init.h"
#include "i2c_init.h"
#include "timer_base.h"
#include "vector.h"
#include "pwm_interrupts.h"
#include "sdfm.h"
volatile uint16_t AutoChange = 0;
volatile uint16_t PWM_out = 0;
volatile uint16_t PWM_out = 2500;
//volatile uint16_t PWM_motor = PERIOD_2;
uint16_t Fault = 0, Fault_fix = 0, Ready = 0, Ready_Fix = 0;
uint16_t counter1s=0, Step = 0;
TMode Mode = OffMode;
uint16_t counter1s=0;
uint16_t FaultABC = 0, FaultABCFix = 0;
uint16_t PwmFlagStartADC = 0;
typedef struct
{
@ -33,10 +36,45 @@ volatile strPWMABC PWM_motor = {PERIOD_2, PERIOD_2, PERIOD_2};
void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC)
{
PWM_motor.UA = PERIOD_2 + (int16_t)(phaseA*PERIOD_2/100.0);
PWM_motor.UB = PERIOD_2 + (int16_t)(phaseB*PERIOD_2/100.0);
PWM_motor.UC = PERIOD_2 + (int16_t)(phaseC*PERIOD_2/100.0);
int16_t A,B,C;
A = (int16_t)(phaseA*(PERIOD_2/100.0));
B = (int16_t)(phaseB*(PERIOD_2/100.0));
C = (int16_t)(phaseC*(PERIOD_2/100.0));
if(A > 0) A+= EPWM_DB/2;
else if(A < 0) A-= EPWM_DB/2;
if(B > 0) B+= EPWM_DB/2;
else if(B < 0) B-= EPWM_DB/2;
if(C > 0) C+= EPWM_DB/2;
else if(C < 0) C-= EPWM_DB/2;
PWM_motor.UA = PERIOD_2 + A;
PWM_motor.UB = PERIOD_2 + B;
PWM_motor.UC = PERIOD_2 + C;
FaultABC = (FaultAL + (FaultAH<<1) + (FaultBL<<2) + (FaultBH<<3) + (FaultCL<<4) + (FaultCH<<5) );
if(FaultABC) FaultABCFix = FaultABC;
if((FaultABC)||(FaultABCFix))
{
PWM_ABC_StopAllClose();
PWM_motor.UA = PERIOD_2;
PWM_motor.UB = PERIOD_2;
PWM_motor.UC = PERIOD_2;
vectorFault();
}
EPwm2Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UA;
EPwm3Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UB;
EPwm4Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UC;
}
//
// epwm1_isr - EPWM1 ISR
//
@ -50,7 +88,7 @@ __interrupt void epwm1_isr(void)
// Clear INT flag for this timer
//
EPwm1Regs.ETCLR.bit.INT = 1;
TimerBaseTimeoutInc();
MainTimerBaseTimeoutInc();
//
@ -62,31 +100,34 @@ __interrupt void epwm1_isr(void)
//
// epwm2_isr - EPWM2 ISR
//
__interrupt void epwm2_isr(void)
{
Gpio20out(1);
// if(AutoChange) pwm_AutoChange(2);
// else
EPwm2Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UA;
EPwm3Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UB;
EPwm4Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UC;
// Gpio54out(1);
// EALLOW;
// Sdfm1Regs.SDDFPARM4.bit.FEN = 1;
// EDIS;
// GpioDataRegs.GPADAT.bit.GPIO0 = 1;
Step++;
if(Mode == StepMode) vector_set_angle(Step);
vector_klark_park(0,0,0,0);
vector_inversion();
FMSTR_enable_set();
Step++;
//
// Clear INT flag for this timer
//
EPwm2Regs.ETCLR.bit.INT = 1;
Gpio20out(0);
TimerBaseTimeoutInc();
if(PwmFlagStartADC) /// àöï íå çàïóñòèëñÿ, òîê íå áûë èçìåðåí
{
PwmFlagStartADC = 0;
FMSTR_enable_set();
}
//
// Acknowledge this interrupt to receive more interrupts from group 3
//
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
// GpioDataRegs.GPADAT.bit.GPIO0 = 0;
// Gpio54out(0);
}
@ -95,8 +136,7 @@ __interrupt void epwm2_isr(void)
//
__interrupt void epwm3_isr(void)
{
// if(AutoChange) pwm_AutoChange(3);
// else
EPwm3Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UB;
//
@ -113,8 +153,7 @@ __interrupt void epwm3_isr(void)
__interrupt void epwm4_isr(void)
{
// if(AutoChange) pwm_AutoChange(4);
// else
EPwm4Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_motor.UC;
//
// Clear INT flag for this timer
@ -129,22 +168,22 @@ __interrupt void epwm4_isr(void)
__interrupt void epwm5_isr(void)
{
Ready = GpioDataRegs.GPADAT.bit.GPIO19;
if(Ready == 0)
{
Ready_Fix = 0;
}
Fault = !GpioDataRegs.GPADAT.bit.GPIO18;
if(Fault || Fault_fix)
{
EPwm5Regs.CMPA.bit.CMPA = PERIOD_BRAKE;
PWM_out = 0;
if(Fault)Fault_fix = 1;
}
else
{
// Ready = GpioDataRegs.GPADAT.bit.GPIO19;
// if(Ready == 0)
// {
// Ready_Fix = 0;
// }
// Fault = !GpioDataRegs.GPADAT.bit.GPIO18;
// if(Fault) Fault_fix = 1;
// if(Fault_fix)
// {
// EPwm5Regs.CMPA.bit.CMPA = PERIOD_BRAKE;
// PWM_out = 0;
// }
// else
// {
EPwm5Regs.CMPA.bit.CMPA = PERIOD_BRAKE - PWM_out;
}
// }
//
// Clear INT flag for this timer
@ -157,12 +196,14 @@ __interrupt void epwm5_isr(void)
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}
float Volt=0;
__interrupt void epwm6_isr(void)
{
// if(AutoChange) pwm_AutoChange(6);
// else
EPwm6Regs.CMPA.bit.CMPA = PERIOD_BRAKE - PWM_out;
EPwm6Regs.CMPA.bit.CMPA = PERIOD_MOTOR - PWM_out;
//
// Clear INT flag for this timer
//
@ -176,6 +217,49 @@ __interrupt void epwm6_isr(void)
uint16_t PWM_test = SDFM_DELAY;
__interrupt void epwm11_isr(void)
{
// Gpio55out(1);
EPwm11Regs.CMPA.bit.CMPA = PWM_test;
EPwm11Regs.CMPB.bit.CMPB = PWM_test;
EPwm11Regs.CMPC = PWM_test;
EPwm11Regs.CMPD = PWM_test;
//
// Clear INT flag for this timer
//
sdfm_clr_index();
EALLOW;
Sdfm1Regs.SDIFLGCLR.all = 0xFFFFFFFF;
Sdfm2Regs.SDIFLGCLR.all = 0xFFFFFFFF;
Sdfm1Regs.SDCPARM4.bit.MFIE = 1;
Sdfm1Regs.SDDFPARM4.bit.AE = 1;
Sdfm2Regs.SDCPARM1.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM1.bit.AE = 1;
Sdfm2Regs.SDCPARM3.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM3.bit.AE = 1;
EDIS;
// vectorControl();
// FMSTR_enable_set();
PwmFlagStartADC = 1;
EPwm11Regs.ETCLR.bit.INT = 1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
// Gpio55out(0);
}
void pwm_clr_PwmFlagStartADC(void)
{
PwmFlagStartADC = 0;
}
//
// InitEPwm1Example - Initialize EPWM1 configuration

9
Projects/epwm_test/src/Peripherals/pwm_interrupts.h
View File

@ -8,11 +8,7 @@
#ifndef SRC_PWM_INTERRUPTS_H_
#define SRC_PWM_INTERRUPTS_H_
typedef enum
{
OffMode, //Ìîòîð îñòàíîâëåí
StepMode, //
}TMode;
__interrupt void epwm1_isr(void);
__interrupt void epwm2_isr(void);
@ -20,8 +16,9 @@ __interrupt void epwm3_isr(void);
__interrupt void epwm4_isr(void);
__interrupt void epwm5_isr(void);
__interrupt void epwm6_isr(void);
__interrupt void epwm11_isr(void);
void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC);
void pwm_clr_PwmFlagStartADC(void);

515
Projects/epwm_test/src/Peripherals/sdfm.c
View File

@ -7,8 +7,11 @@
#include "f28x_project.h"
#include "f2838x_sdfm_drivers.h"
#include "f2838x_sdfm.h"
#include "gpio_init.h"
#include "sdfm.h"
#include "vector.h"
#include"frm_uart.h"
//
// Defines
//
@ -21,6 +24,8 @@
#define EPWM_TIMER_TBPRD 65535 // ePWM Period register
#define SDFM_INT_MASK 0x80001000U
//
// Globals
//
@ -31,50 +36,97 @@ int16_t Filter1_Result[MAX_SAMPLES];
int16_t Filter3_Result[MAX_SAMPLES];
int16_t Filter2_Result[MAX_SAMPLES];
int16_t Filter4_Result[MAX_SAMPLES];
int16_t Filter5_Result[MAX_SAMPLES];
int16_t Filter6_Result[MAX_SAMPLES];
int16_t Filter7_Result[MAX_SAMPLES];
int16_t Filter8_Result[MAX_SAMPLES];
#pragma DATA_SECTION(Filter1_Result,"Filter1_RegsFile");
#pragma DATA_SECTION(Filter2_Result,"Filter2_RegsFile");
#pragma DATA_SECTION(Filter3_Result,"Filter3_RegsFile");
#pragma DATA_SECTION(Filter4_Result,"Filter4_RegsFile");
int16_t ADC_ampere = 0;
int16_t sdfmOffset = 0;
#pragma DATA_SECTION(Filter5_Result,"Filter1_RegsFile");
#pragma DATA_SECTION(Filter6_Result,"Filter2_RegsFile");
#pragma DATA_SECTION(Filter7_Result,"Filter3_RegsFile");
#pragma DATA_SECTION(Filter8_Result,"Filter4_RegsFile");
//union SDCPARM1_REG * SDCPARM_Reg_arr[4] = {&Sdfm1Regs.SDCPARM1, &Sdfm1Regs.SDCPARM2, &Sdfm1Regs.SDCPARM3, &Sdfm1Regs.SDCPARM4};
int16_t sdfmAdc[8] = {0,0,0,0,0,0,0,0};
int16_t sdfmAdcErr[8] = {0,0,0,0,0,0,0,0};
int16_t sdfmOffset[8] = {0,0,0,0,0,0,0,0};
uint16_t startInitCurrent = 0;
uint16_t initDone = 0;
uint16_t initDone[8] = {3,3,3,3,3,3,3,3};
uint32_t IntFlags1, IntFlags2;
uint16_t sdfmIndex = 0;
int16_t Test_I[16];
__interrupt void Sdfm1_ISR(void);
__interrupt void Sdfm2_ISR(void);
volatile float CurrentFactorBrake = FACTOR_CURRENT_BRAKE_A;
volatile float CurrentFactorMotor = FACTOR_CURRENT_MOTOR_A;
volatile float CurrentFactorBrake = FACTOR_CURRENT_BRAKE*32767.0;
volatile float CurrentFactorMotor = FACTOR_CURRENT_MOTOR*32767.0;
volatile float VdcFactor = FACTOR_VDC;
int16_t SdfmGetChannel(int16_t N)
{
return sdfmAdc[N];
}
void SdfmGpioInit(void)
{
EALLOW;
GPIO_SetupPinOptions(16, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(16,GPIO_MUX_CPU1,7); //SDFM-1 Channel 1 Data Input
GPIO_SetupPinMux(16,GPIO_MUX_CPU1,7); //SDFM-1 Channel 1 Data Input (brake)
GPIO_SetupPinOptions(17, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(17,GPIO_MUX_CPU1,7); //SDFM-1 Channel 1 Clock Input
GPIO_SetupPinOptions(22, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(22,GPIO_MUX_CPU1,7); //SDFM-1 Channel 4 Data Input
GPIO_SetupPinMux(22,GPIO_MUX_CPU1,7); //SDFM-1 Channel 4 Data Input (Iv)b
GPIO_SetupPinOptions(23, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(23,GPIO_MUX_CPU1,7); //SDFM-1 Channel 4 Clock Input
GPIO_SetupPinOptions(24, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(24,GPIO_MUX_CPU1,7); //SDFM-2 Channel 1 Data Input
GPIO_SetupPinMux(24,GPIO_MUX_CPU1,7); //SDFM-2 Channel 1 Data Input (Iw)c
GPIO_SetupPinOptions(25, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(25,GPIO_MUX_CPU1,7); //SDFM-2 Channel 1 Clock Input
GPIO_SetupPinOptions(58, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(58,GPIO_MUX_CPU1,7); //SDFM-2 Channel 2 Data Input
GPIO_SetupPinMux(58,GPIO_MUX_CPU1,7); //SDFM-2 Channel 2 Data Input (Udc)
GPIO_SetupPinOptions(59, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(59,GPIO_MUX_CPU1,7); //SDFM-2 Channel 2 Clock Input
GPIO_SetupPinOptions(60, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(60,GPIO_MUX_CPU1,7); //SDFM-2 Channel 3 Data Input
GPIO_SetupPinMux(60,GPIO_MUX_CPU1,7); //SDFM-2 Channel 3 Data Input (Iu)a
GPIO_SetupPinOptions(61, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(61,GPIO_MUX_CPU1,7); //SDFM-2 Channel 3 Clock Input
GPIO_SetupPinOptions(62, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(62,GPIO_MUX_CPU1,7); //SDFM-2 Channel 4 Data Input (sin)
GPIO_SetupPinOptions(63, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(63,GPIO_MUX_CPU1,7); //SDFM-2 Channel 4 Clock Input
GPIO_SetupPinOptions(65, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(65,GPIO_MUX_CPU1,13); //SDFM-1 Channel 2 Data Input (cos)
GPIO_SetupPinOptions(66, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(66,GPIO_MUX_CPU1,13); //SDFM-1 Channel 2 Clock Input
GPIO_SetupPinOptions(67, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(67,GPIO_MUX_CPU1,13); //SDFM-1 Channel 3 Data Input (ref)
GPIO_SetupPinOptions(68, GPIO_INPUT, GPIO_ASYNC);
GPIO_SetupPinMux(68,GPIO_MUX_CPU1,13); //SDFM-1 Channel 3 Clock Input
EDIS;
}
@ -92,34 +144,32 @@ void SdfmInitInterruptEn(void)
PieVectTable.SDFM2_INT = &Sdfm2_ISR;
IER |= M_INT5;
PieCtrlRegs.PIEIER5.bit.INTx9 = 1; // SDFM1 interrupt enabled
// PieCtrlRegs.PIEIER5.bit.INTx10 = 1; // SDFM2 interrupt enabled
PieCtrlRegs.PIEIER5.bit.INTx10 = 1; // SDFM2 interrupt enabled
EDIS;
}
void SdfmInit(void)
{
uint16_t HLT, LLT;
//
// Configure SDFM type to 0
//
EALLOW;
DevCfgRegs.SDFMTYPE.all = 0x8000;
EDIS;
//
// Input Control Module
//
// Configure Input Control Mode: Modulator Clock rate = Modulator data rate
//
Sdfm_configureInputCtrl(SDFM1, FILTER1, MODE_0);
// Sdfm_configureInputCtrl(SDFM1, FILTER4, MODE_0);
// Sdfm_configureInputCtrl(SDFM2, FILTER1, MODE_0);
// Sdfm_configureInputCtrl(SDFM2, FILTER2, MODE_0);
// Sdfm_configureInputCtrl(SDFM2, FILTER3, MODE_0);
Sdfm_configureInputCtrl(SDFM1, FILTER2, MODE_0);
Sdfm_configureInputCtrl(SDFM1, FILTER3, MODE_0);
Sdfm_configureInputCtrl(SDFM1, FILTER4, MODE_0);
Sdfm_configureInputCtrl(SDFM2, FILTER1, MODE_0);
Sdfm_configureInputCtrl(SDFM2, FILTER2, MODE_0);
Sdfm_configureInputCtrl(SDFM2, FILTER3, MODE_0);
Sdfm_configureInputCtrl(SDFM2, FILTER4, MODE_0);
//
// Comparator Module
//
@ -131,10 +181,13 @@ void SdfmInit(void)
// value, higher threshold, lower threshold
//
Sdfm_configureComparator(SDFM1, FILTER1, SINC3, OSR_32, HLT, LLT);
// Sdfm_configureComparator(SDFM1, FILTER4, SINC3, OSR_32, HLT, LLT);
// Sdfm_configureComparator(SDFM2, FILTER1, SINC3, OSR_32, HLT, LLT);
// Sdfm_configureComparator(SDFM2, FILTER2, SINC3, OSR_32, HLT, LLT);
// Sdfm_configureComparator(SDFM2, FILTER3, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM1, FILTER2, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM1, FILTER3, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM1, FILTER4, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM2, FILTER1, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM2, FILTER2, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM2, FILTER3, SINC3, OSR_32, HLT, LLT);
Sdfm_configureComparator(SDFM2, FILTER4, SINC3, OSR_32, HLT, LLT);
//
// Enable Master filter bit: Unless this bit is set none of the filter modules
// can be enabled. All the filter modules are synchronized when master filter
@ -143,170 +196,458 @@ void SdfmInit(void)
// individual filter modules are enabled.
//
Sdfm_enableMFE(SDFM1);
// Sdfm_enableMFE(SDFM2);
Sdfm_enableMFE(SDFM2);
//
// Data filter Module
//
// Configure Data filter modules filter type, OSR value and
// enable / disable data filter
//
Sdfm_configureData_filter(SDFM1, FILTER1, FILTER_ENABLE, SINC3, OSR_256, DATA_16_BIT, SHIFT_9_BITS);
// Sdfm_configureData_filter(SDFM1, FILTER4, FILTER_ENABLE, SINC3, OSR_256, DATA_16_BIT, SHIFT_9_BITS);
// Sdfm_configureData_filter(SDFM2, FILTER1, FILTER_ENABLE, SINC3, OSR_256, DATA_16_BIT, SHIFT_9_BITS);
// Sdfm_configureData_filter(SDFM2, FILTER2, FILTER_ENABLE, SINC3, OSR_256, DATA_16_BIT, SHIFT_9_BITS);
// Sdfm_configureData_filter(SDFM2, FILTER3, FILTER_ENABLE, SINC3, OSR_256, DATA_16_BIT, SHIFT_9_BITS);
Sdfm_configureData_filter(SDFM1, FILTER1, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM1, FILTER2, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM1, FILTER3, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM1, FILTER4, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM2, FILTER1, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM2, FILTER2, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM2, FILTER3, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
Sdfm_configureData_filter(SDFM2, FILTER4, FILTER_DISABLE, SINC3, OSR_32, DATA_16_BIT, SHIFT_0_BITS);
EALLOW;
// Sdfm1Regs.SDSYNC1.bit.SYNCSEL = 0;
// Sdfm1Regs.SDSYNC1.bit.SYNCSEL = 0x3F;
// Sdfm2Regs.SDSYNC1.bit.SYNCSEL = 0x3F;
// Sdfm1Regs.SDSYNC2.bit.SYNCSEL = 0x3F;
// Sdfm2Regs.SDSYNC2.bit.SYNCSEL = 0x3F;
// Sdfm1Regs.SDSYNC3.bit.SYNCSEL = 0x3F;
// Sdfm2Regs.SDSYNC3.bit.SYNCSEL = 0x3F;
// Sdfm1Regs.SDSYNC4.bit.SYNCSEL = 0x3F;
// Sdfm2Regs.SDSYNC4.bit.SYNCSEL = 0x3F;
Sdfm1Regs.SDDFPARM1.bit.SDSYNCEN = 0;
Sdfm2Regs.SDDFPARM1.bit.SDSYNCEN = 0;
Sdfm1Regs.SDDFPARM2.bit.SDSYNCEN = 0;
Sdfm2Regs.SDDFPARM2.bit.SDSYNCEN = 0;
Sdfm1Regs.SDDFPARM3.bit.SDSYNCEN = 0;
Sdfm2Regs.SDDFPARM3.bit.SDSYNCEN = 0;
Sdfm1Regs.SDDFPARM4.bit.SDSYNCEN = 0;
Sdfm2Regs.SDDFPARM4.bit.SDSYNCEN = 0;
EDIS;
// Sdfm_configureExternalreset(gPeripheralNumber,FILTER_1_EXT_RESET_ENABLE,0,0,0);
Sdfm_configureInterrupt(SDFM1, FILTER1, IEH_DISABLE,
IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM1, FILTER1, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM1, FILTER2, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM1, FILTER3, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM1, FILTER4, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
////
// Sdfm_configureInterrupt(SDFM2, FILTER1, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM2, FILTER2, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM2, FILTER3, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
// Sdfm_configureInterrupt(SDFM2, FILTER4, IEH_DISABLE, IEL_DISABLE, MFIE_ENABLE, AE_ENABLE);
//
// Enable master interrupt so that any of the filter interrupts can trigger
// by SDFM interrupt to CPU
//
//Sdfm1Regs.SDCPARM4.bit.MFIE = 1;
//Sdfm1Regs.SDDFPARM4.bit.AE = 1;
Sdfm_enableMIE(SDFM1);
Sdfm_enableMIE(SDFM2);
EALLOW;
Sdfm1Regs.SDDFPARM1.bit.FEN = 1;
Sdfm1Regs.SDDFPARM2.bit.FEN = 1;
Sdfm1Regs.SDDFPARM3.bit.FEN = 1;
Sdfm1Regs.SDDFPARM4.bit.FEN = 1;
Sdfm2Regs.SDDFPARM1.bit.FEN = 1;
Sdfm2Regs.SDDFPARM2.bit.FEN = 1;
Sdfm2Regs.SDDFPARM3.bit.FEN = 1;
Sdfm2Regs.SDDFPARM4.bit.FEN = 1;
EDIS;
}
//
// Sdfm1_ISR - SDFM 1 ISR
//
__interrupt void Sdfm1_ISR(void)
{
static uint16_t loopCounter1 = 0;
static uint16_t loopCounter2 = 0;
static uint16_t loopCounter3 = 0;
static uint16_t loopCounter4 = 0;
uint16_t i = 0;
int32_t OffsetCount = 0;
Gpio21out(1);
//
// Wait for result from all the filters (SDIFLG)
//
uint32_t IntFlags = Sdfm_readFlagRegister(SDFM1);
// while((Sdfm_readFlagRegister(SDFM1) &
// SDFM_INT_MASK) != SDFM_INT_MASK);
if (IntFlags & 0x1000)
IntFlags1 = Sdfm_readFlagRegister(SDFM1);
sdfmIndex |= (IntFlags1 & 0xF000)>>12;
if (IntFlags1 & 0x1000)
{
if(loopCounter1 >= (MAX_SAMPLES-1))
Filter1_Result[loopCounter1] = SDFM1_READ_FILTER1_DATA_16BIT;
sdfmAdc[0] = Filter1_Result[loopCounter1] - sdfmOffset[0];
if(loopCounter1 < MAX_SAMPLES) loopCounter1++;
else
{
loopCounter1 = 0;
if(startInitCurrent < SKIP_FIRST) startInitCurrent++;
else if(!initDone)
if(!initDone[0])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter1_Result[i];
}
sdfmOffset = OffsetCount>>FILTER_BIT;
initDone = 1;
sdfmOffset[0] = OffsetCount>>FILTER_BIT;
initDone[0] = 0xFF;
}
else if(initDone[0] != 0xFF) initDone[0]--;
}
Filter1_Result[loopCounter1++] = SDFM1_READ_FILTER1_DATA_16BIT;
ADC_ampere = Filter1_Result[loopCounter1-1] - sdfmOffset;
EALLOW;
Sdfm1Regs.SDCPARM1.bit.MFIE = 1;
Sdfm1Regs.SDDFPARM1.bit.AE = 0;
EDIS;
sdfmAdcErr[0] = 0;
}
if (IntFlags1 & 0x2000)
{
Filter2_Result[loopCounter2] = SDFM1_READ_FILTER2_DATA_16BIT;
sdfmAdc[1] = Filter2_Result[loopCounter2] - sdfmOffset[1];
if(loopCounter2 < MAX_SAMPLES) loopCounter2++;
else
{
loopCounter2 = 0;
if(!initDone[1])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter2_Result[i];
}
sdfmOffset[1] = OffsetCount>>FILTER_BIT;
initDone[1] = 0xFF;
}
else if(initDone[1] != 0xFF) initDone[1]--;
}
EALLOW;
Sdfm1Regs.SDCPARM2.bit.MFIE = 1;
Sdfm1Regs.SDDFPARM2.bit.AE = 0;
EDIS;
sdfmAdcErr[1] = 0;
}
if (IntFlags1 & 0x4000)
{
Filter3_Result[loopCounter3] = SDFM1_READ_FILTER3_DATA_16BIT;
sdfmAdc[2] = Filter3_Result[loopCounter3] - sdfmOffset[2];
if(loopCounter3 < MAX_SAMPLES) loopCounter3++;
else
{
loopCounter3 = 0;
if(!initDone[2])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter3_Result[i];
}
sdfmOffset[2] = OffsetCount>>FILTER_BIT;
initDone[2] = 0xFF;
}
else if(initDone[2] != 0xFF) initDone[2]--;
}
EALLOW;
Sdfm1Regs.SDCPARM3.bit.MFIE = 1;
Sdfm1Regs.SDDFPARM3.bit.AE = 0;
EDIS;
sdfmAdcErr[2] = 0;
}
if (IntFlags1 & 0x8000)
{
Gpio15out(1);
Filter4_Result[loopCounter4] = SDFM1_READ_FILTER4_DATA_16BIT;
sdfmAdc[3] = Filter4_Result[loopCounter4] - sdfmOffset[3];
// Test_I[sdfm_index] = sdfmAdc[3];
// sdfm_index++;
// if(sdfm_index >= 15)
// {
// EALLOW;
// Sdfm1Regs.SDDFPARM4.bit.FEN = 0;
// EDIS;
// }
Gpio15out(0);
if(loopCounter4 < MAX_SAMPLES) loopCounter4++;
else
{
loopCounter4 = 0;
if(!initDone[3])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter4_Result[i];
}
sdfmOffset[3] = OffsetCount>>FILTER_BIT;
initDone[3] = 0xFF;
}
else if(initDone[3] != 0xFF) initDone[3]--;
}
EALLOW;
Sdfm1Regs.SDCPARM4.bit.MFIE = 1;
Sdfm1Regs.SDDFPARM4.bit.AE = 0;
EDIS;
sdfmAdcErr[3] = 0;
}
if(IntFlags & 0x100)
if(IntFlags1 & 0x100)
{
ADC_ampere = 0;
sdfmAdc[0] = 0;
EALLOW;
Sdfm1Regs.SDCPARM1.bit.MFIE = 0;
EDIS;
}
else
{
EALLOW;
Sdfm1Regs.SDCPARM1.bit.MFIE = 1;
EDIS;
sdfmAdcErr[0] = 1;
}
if(IntFlags1 & 0x200)
{
sdfmAdc[1] = 0;
EALLOW;
Sdfm1Regs.SDCPARM2.bit.MFIE = 0;
EDIS;
sdfmAdcErr[1] = 1;
}
if(IntFlags1 & 0x400)
{
sdfmAdc[2] = 0;
EALLOW;
Sdfm1Regs.SDCPARM3.bit.MFIE = 0;
EDIS;
sdfmAdcErr[2] = 1;
}
if(IntFlags1 & 0x800)
{
vectorFault();
sdfmAdc[3] = 0;
EALLOW;
Sdfm1Regs.SDCPARM4.bit.MFIE = 0;
EDIS;
sdfmAdcErr[3] = 1;
}
//
// Clear SDFM flag register
//
Sdfm_clearFlagRegister(SDFM1,IntFlags);
Sdfm_clearFlagRegister(SDFM1,IntFlags1);
if((sdfmIndex & 0x58) == 0x58)
{
Gpio54out(1);
sdfmIndex = 0;
vectorControl(sdfmAdc[6],sdfmAdc[3],sdfmAdc[4]);
Gpio54out(0);
}
//
// Acknowledge this __interrupt to receive more __interrupts from group 5
//
PieCtrlRegs.PIEACK.all = PIEACK_GROUP5;
Gpio21out(0);
}
//
// Sdfm1_ISR - SDFM 1 ISR
//
__interrupt void Sdfm2_ISR(void)
{
static uint16_t loopCounter1 = 0;
static uint16_t loopCounter5 = 0;
static uint16_t loopCounter6 = 0;
static uint16_t loopCounter7 = 0;
static uint16_t loopCounter8 = 0;
uint16_t i = 0;
int32_t OffsetCount = 0;
Gpio21out(1);
//
// Wait for result from all the filters (SDIFLG)
//
uint32_t IntFlags = Sdfm_readFlagRegister(SDFM2);
IntFlags2 = Sdfm_readFlagRegister(SDFM2);
sdfmIndex |= (IntFlags2&0xF000)>>8;
// while((Sdfm_readFlagRegister(gPeripheralNumber) &
// SDFM_INT_MASK) != SDFM_INT_MASK);
if (IntFlags & 0x1000)
if (IntFlags2 & 0x1000)
{
if(loopCounter1 >= (MAX_SAMPLES-1))
Gpio56out(1);
Filter5_Result[loopCounter5] = SDFM2_READ_FILTER1_DATA_16BIT;
sdfmAdc[4] = Filter5_Result[loopCounter5] - sdfmOffset[4];
Gpio56out(0);
if(loopCounter5 < MAX_SAMPLES) loopCounter5++;
else
{
loopCounter1 = 0;
if(startInitCurrent < SKIP_FIRST) startInitCurrent++;
else if(!initDone)
loopCounter5 = 0;
if(!initDone[4])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter1_Result[i];
OffsetCount += Filter5_Result[i];
}
sdfmOffset = OffsetCount>>FILTER_BIT;
initDone = 1;
sdfmOffset[4] = OffsetCount>>FILTER_BIT;
initDone[4] = 0xFF;
}
else if(initDone[4] != 0xFF) initDone[4]--;
}
Filter1_Result[loopCounter1++] = SDFM1_READ_FILTER1_DATA_16BIT;
ADC_ampere = Filter1_Result[loopCounter1-1] - sdfmOffset;
EALLOW;
Sdfm2Regs.SDCPARM1.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM1.bit.AE = 0;
EDIS;
sdfmAdcErr[4] = 0;
}
if (IntFlags2 & 0x2000)
{
Filter6_Result[loopCounter6] = SDFM2_READ_FILTER2_DATA_16BIT;
sdfmAdc[5] = Filter6_Result[loopCounter6] - sdfmOffset[5];
if(loopCounter6 < MAX_SAMPLES) loopCounter6++;
else
{
loopCounter6 = 0;
if(!initDone[5])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter6_Result[i];
}
sdfmOffset[5] = OffsetCount>>FILTER_BIT;
initDone[5] = 0xFF;
}
else if(initDone[5] != 0xFF) initDone[5]--;
}
EALLOW;
Sdfm2Regs.SDCPARM2.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM2.bit.AE = 0;
EDIS;
sdfmAdcErr[5] = 0;
}
if (IntFlags2 & 0x4000)
{
Gpio57out(1);
Filter7_Result[loopCounter7] = SDFM2_READ_FILTER3_DATA_16BIT;
sdfmAdc[6] = Filter7_Result[loopCounter7] - sdfmOffset[6];
Gpio57out(0);
if(loopCounter7 < MAX_SAMPLES) loopCounter7++;
else
{
loopCounter7 = 0;
if(!initDone[6])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter7_Result[i];
}
sdfmOffset[6] = OffsetCount>>FILTER_BIT;
initDone[6] = 0xFF;
}
else if(initDone[6] != 0xFF) initDone[6]--;
}
EALLOW;
Sdfm2Regs.SDCPARM3.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM3.bit.AE = 0;
EDIS;
sdfmAdcErr[6] = 0;
}
if (IntFlags2 & 0x8000)
{
Filter8_Result[loopCounter8] = SDFM2_READ_FILTER4_DATA_16BIT;
sdfmAdc[7] = Filter8_Result[loopCounter8] - sdfmOffset[7];
if(loopCounter8 < MAX_SAMPLES) loopCounter8++;
else
{
loopCounter8 = 0;
if(!initDone[7])
{
for(i = 0; i <= (MAX_SAMPLES-1); i++)
{
OffsetCount += Filter8_Result[i];
}
sdfmOffset[7] = OffsetCount>>FILTER_BIT;
initDone[7] = 0xFF;
}
else if(initDone[7] != 0xFF) initDone[7]--;
}
EALLOW;
Sdfm2Regs.SDCPARM4.bit.MFIE = 1;
Sdfm2Regs.SDDFPARM4.bit.AE = 0;
EDIS;
sdfmAdcErr[7] = 0;
}
if(IntFlags & 0x100)
if(IntFlags2 & 0x100)
{
ADC_ampere = 0;
vectorFault();
sdfmAdc[4] = 0;
EALLOW;
Sdfm1Regs.SDCPARM1.bit.MFIE = 0;
Sdfm2Regs.SDCPARM1.bit.MFIE = 0;
EDIS;
sdfmAdcErr[4] = 1;
}
else
if(IntFlags2 & 0x200)
{
sdfmAdc[5] = 0;
EALLOW;
Sdfm1Regs.SDCPARM1.bit.MFIE = 1;
Sdfm2Regs.SDCPARM2.bit.MFIE = 0;
EDIS;
sdfmAdcErr[5] = 1;
}
if(IntFlags2 & 0x400)
{
vectorFault();
sdfmAdc[6] = 0;
EALLOW;
Sdfm2Regs.SDCPARM3.bit.MFIE = 0;
EDIS;
sdfmAdcErr[6] = 1;
}
if(IntFlags2 & 0x800)
{
sdfmAdc[7] = 0;
EALLOW;
Sdfm2Regs.SDCPARM4.bit.MFIE = 0;
EDIS;
sdfmAdcErr[7] = 1;
}
//
// Clear SDFM flag register
//
Sdfm_clearFlagRegister(SDFM2,IntFlags);
Sdfm_clearFlagRegister(SDFM2,IntFlags2);
if((sdfmIndex & 0x58) == 0x58)
{
Gpio54out(1);
sdfmIndex = 0;
vectorControl(sdfmAdc[6],sdfmAdc[3],sdfmAdc[4]);
Gpio54out(0);
}
// sdfmIndex &= 0xF;
//
// Acknowledge this __interrupt to receive more __interrupts from group 5
//
PieCtrlRegs.PIEACK.all = PIEACK_GROUP5;
Gpio21out(0);
}
void sdfm_clr_index(void)
{
sdfmIndex = 0;
}
int16_t sdfm_get(int16_t N)
{
return sdfmAdc[N];
}
//Sdfm_clearFlagRegister

36
Projects/epwm_test/src/Peripherals/sdfm.h
View File

@ -8,21 +8,41 @@
#ifndef SRC_SDFM_H_
#define SRC_SDFM_H_
#define SDFM_VOLTAGE_MAX 320.0 //mV
#define R_BRAKE 220.0 //mOM
#define R_DRW 4.0 //mOM
#define SDFM_IA 6
#define SDFM_IB 3
#define SDFM_IC 4
#define FACTOR_CURRENT_BRAKE_A (SDFM_VOLTAGE_MAX/R_BRAKE) //A íŕ 32768ĺä.
#define FACTOR_CURRENT_MOTOR_A (SDFM_VOLTAGE_MAX/R_DRW) //A íŕ 32768ĺä.
#define SDFM_BRAKE 0
#define SDFM_U_DC 5
#define FACTOR_CURRENT_BRAKE (FACTOR_CURRENT_BRAKE_A/32768.0)
#define FACTOR_CURRENT_MOTOR (FACTOR_CURRENT_MOTOR_A/32768.0)
#define SDFM_SIN 7
#define SDFM_COS 1
#define SDFM_REF 2
#define SDFM_VOLTAGE_MAX 320.0 //mV
#define R_BRAKE 220.0 //mOM
#define R_DRW 4.0 //mOM
#define R_VDC 806.0 //Om
#define R_DEL_VDC 2000000.0 //Om
#define BIT_MAX 32768//4096
#define FACTOR_VDC (SDFM_VOLTAGE_MAX/R_VDC*(R_DEL_VDC+R_VDC)/1000)
#define FACTOR_CURRENT_BRAKE_A (SDFM_VOLTAGE_MAX/R_BRAKE) //A
#define FACTOR_CURRENT_MOTOR_A (SDFM_VOLTAGE_MAX/R_DRW) //A
#define FACTOR_CURRENT_BRAKE (FACTOR_CURRENT_BRAKE_A/BIT_MAX)
#define FACTOR_CURRENT_MOTOR (FACTOR_CURRENT_MOTOR_A/BIT_MAX)
void SdfmGpioInit(void);
void SdfmInitEnable(void);
void SdfmInitInterruptEn(void);
void SdfmInit(void);
void sdfm_clr_index(void);
int16_t sdfm_get(int16_t N);

6
Projects/epwm_test/src/frm_uart.c
View File

@ -85,10 +85,12 @@ void FRMUartInit(void)
// SCIA at 115200 baud
// @LSPCLK = 50 MHz (200 MHz SYSCLK) HBAUD = 0x00 and LBAUD = 0x35.
//
SciaRegs.SCIHBAUD.all = 0x0000;
SciaRegs.SCILBAUD.all = 0x006F;
SciaRegs.SCIHBAUD.all = 0x0001;
SciaRegs.SCILBAUD.all = 0x0045;
SciaRegs.SCICTL1.all = 0x0023; // Relinquish SCI from Reset
FMSTR_enable_set();
}

1
Projects/epwm_test/src/frmmstr_run.c
View File

@ -7,6 +7,7 @@
#include "f28x_project.h"
#include "init_perif.h"
#include "frm_uart.h"
#include "gpio_init.h"
volatile uint16_t counter=0 ;
volatile uint16_t counter1=0 ;

85
Projects/epwm_test/src/skvt.c Normal file
View File

@ -0,0 +1,85 @@
/*
* skvt.c
*
* Created on: 11 îêò. 2023 ã.
* Author: seklyuts
*/
#include "f28x_project.h"
#include "skvt.h"
/*
1) t = arctan(sin/cos)
2) t = PI/2-arctan(cos/sin)
3) t = PI/2+arctan(-cos/sin)
4) t = PI-arctan(sin/-cos)
5) t = -PI+arctan(-sin/-cos)
6) t = -PI/2-arctan(-cos/-sin)
7) t = -PI/2+arctan(cos/-sin)
8) t = -arctan(-sin/cos)
y= -0.0915 x^2 + 0.3434x - 0.0015
*/
#define A_p -FRAC16(0.0915)
#define B_p FRAC16(0.3434)
#define C_p -FRAC16(0.0015)
int16_t AngleSector;
int16_t mult_r(int16_t x, int16_t y) { return (int16_t) (((int32_t) (x) * (y)) >> 15); }
int16_t Atan_approximation(int16_t x)
{
int16_t xx,y;
if (x<0) y = FRAC16(0.25); //x=32767;//it will be so if (sin == cos), because (x<<15)/x = (x * 2^8)/x = 2^8 = 0x8000 = -32768;
else {
if(x <= C_p) y = 0;
else {
xx=mult_r(x,x);
y = mult_r(xx,A_p) + mult_r(x,B_p) + C_p;
}
}
return (y);
}
int16_t Atan(int16_t rSinA, int16_t rCosA)
{
int16_t theta_actual_el_1 = 0;
int16_t MrCosA, MrSinA;
if(rSinA >= 0) {
if(rCosA >= 0) { //0 < 0.5
if(rSinA < rCosA) { AngleSector=1;
theta_actual_el_1 = Atan_approximation(((int32_t)rSinA<<15)/rCosA);
} else { AngleSector = 2;
theta_actual_el_1 = FRAC16(0.5)-Atan_approximation(((int32_t)rCosA<<15)/rSinA);
}
} else { //0.5 < 1
MrCosA = abs(rCosA);
if(rSinA < MrCosA) { AngleSector = 4;
theta_actual_el_1 = FRAC16(1)-Atan_approximation(((int32_t)rSinA<<15)/MrCosA);
} else { AngleSector = 3;
theta_actual_el_1 = FRAC16(0.5)+Atan_approximation(((int32_t)MrCosA<<15)/rSinA);
}
}
} else {
MrSinA = abs(rSinA);
if(rCosA >= 0) { //0 > -0.5
if(MrSinA < rCosA) { AngleSector = 8;
theta_actual_el_1 = -Atan_approximation(((int32_t)MrSinA<<15)/rCosA);
} else { AngleSector = 7;
theta_actual_el_1 = -FRAC16(0.5)+Atan_approximation(((int32_t)rCosA<<15)/MrSinA);
}
} else { //-0.5 > -1
MrCosA = abs(rCosA);
if(MrSinA < MrCosA) { AngleSector = 5;
theta_actual_el_1 = -FRAC16(1)+Atan_approximation(((int32_t)MrSinA<<15)/MrCosA);
} else { AngleSector = 6;
theta_actual_el_1 = -FRAC16(0.5)-Atan_approximation(((int32_t)MrCosA<<15)/MrSinA);
}
}
}
return(theta_actual_el_1);
}

16
Projects/epwm_test/src/skvt.h Normal file
View File

@ -0,0 +1,16 @@
/*
* skvt.h
*
* Created on: 11 îêò. 2023 ã.
* Author: seklyuts
*/
#ifndef SRC_SKVT_H_
#define SRC_SKVT_H_
#define FRAC16(x) ((int16_t)((x) < 1 ? ((x) >= -1 ? ((int16_t)((x)*0x8000)) : ((int16_t)0x8000)) : ((int16_t)0x7FFF)))
int16_t Atan_approximation(int16_t x);
int16_t Atan(int16_t rSinA, int16_t rCosA);
#endif /* SRC_SKVT_H_ */

126
Projects/epwm_test/src/vector.c
View File

@ -8,10 +8,18 @@
#include "f28x_project.h"
#include "pwm_interrupts.h"
#include "pwm_init.h"
#include "pi.h"
#include "vector.h"
#include "iqmath.h"
#include "sdfm.h"
#include "gpio_init.h"
#include "frm_uart.h"
#include "skvt.h"
#define IMAX_A 10.0 //A
#define IMAX (IMAX_A*BIT_MAX/FACTOR_CURRENT_MOTOR_A)
const int16_t mcgenSineTable256[257] = \
@ -43,14 +51,65 @@ const int16_t mcgenSineTable256[257] = \
-32745,-32752,-32758,-32762,-32765,-32767,-32767 };
int16_t Ia,Ib,Ic;
Tvector2dq vectorUdq, vectorIdq;
Tvector2ph vectorU2ph, vectorI2ph;
Tvector3abc vectorUabc, vectorIabc;
TvectorSinCos vectorSinCos;
uint16_t VecSector;
uint16_t VecSector, OverCur[3] = {0,0,0}, ErrCur=0, CurFault = 0;
float FactorCurrent = FACTOR_CURRENT_MOTOR;
TvectorCurrentLoop CurrLoop;
TMode Mode = OffMode;
uint16_t Step = 0, StepS, Nstep = 2, NoLoop = 0, StepShift = 6;
float CurrentRegTuneAmpl = 0, FRM_cur = 0;
int16_t Angle_test=0,sin_int,cos_int;
void vectorFault(void)
{
Mode = OffMode;
}
void vectorControl(int16_t CurrentA, int16_t CurrentB, int16_t CurrentC)
{
pwm_clr_PwmFlagStartADC();
Ia = CurrentA;//sdfm_get(6);
Ib = CurrentB;//sdfm_get(3);
Ic = CurrentC;//sdfm_get(4);
if((Ia > IMAX)||(Ib>IMAX)||(Ic>IMAX)||(Ia<-IMAX)||(Ib<-IMAX)||(Ic<-IMAX) ) {OverCur[0] = Ia; OverCur[1] = Ib; OverCur[2] = Ic; ErrCur++; if(ErrCur >= 3) {Mode = OffMode; CurFault++;}}
else ErrCur = 0;
Step = Step + Nstep;
CurrLoop.piId.Ref = 0;
switch(Mode)
{
case OffMode:
PWM_ABC_StopAllClose();
vectorResCurrLoop();
break;
case StepMode:
PWM_ABC_StartOut();
vectorSinCos.Angle = Step;
CurrLoop.piIq.Ref = CurrentRegTuneAmpl;
break;
case StayMode:
PWM_ABC_StartOut();
break;
case CurrentRegTune:
vectorSinCos.Angle = 0;
PWM_ABC_StartOut();
StepS = Step&((1<<StepShift)-1);
if(StepS > (1<<(StepShift-1))) CurrLoop.piId.Ref = 0;
else CurrLoop.piId.Ref = CurrentRegTuneAmpl;
break;
default:
Mode = OffMode;
PWM_ABC_StopAllClose();
}
vector_klark_park(1,Ia,Ib,Ic);
vector_inversion();
FMSTR_enable_set();
}
void vectorInitCurrLoop(void)
{
@ -84,11 +143,22 @@ void vectorInitCurrLoop(void)
CurrLoop.piIq.i1 = 0; // Data: integrator storage: ui(k-1)
}
void vector_set_angle(int16_t val)
void vectorResCurrLoop(void)
{
vectorSinCos.Angle = val;
CurrLoop.piId.Ref = 0; // Input: reference set-point
CurrLoop.piId.uCorr = 0; // Input: Êîððåêöèÿ âûõîäà, äëÿ óñòðàíåíèÿ ïåðåêðåòíûõ ñâÿçåé
CurrLoop.piId.Out = 0; // Output: controller output
CurrLoop.piId.v1 = 0; // Data: pre-saturated controller output
CurrLoop.piId.i1 = 0; // Data: integrator storage: ui(k-1)
CurrLoop.piIq.Ref = 0; // Input: reference set-point
CurrLoop.piIq.uCorr = 0; // Input: Êîððåêöèÿ âûõîäà, äëÿ óñòðàíåíèÿ ïåðåêðåòíûõ ñâÿçåé
CurrLoop.piIq.Out = 0; // Output: controller output
CurrLoop.piIq.v1 = 0; // Data: pre-saturated controller output
CurrLoop.piIq.i1 = 0; // Data: integrator storage: ui(k-1)
}
int16_t vector_mcsinPIxLUT(int16_t Value, int16_t *psinTable)
{
// set saturation on
@ -111,12 +181,11 @@ void vector_inversion(void)
{
float temp1, temp2, temp3;
// vectorSinCos.sin = ((float)mcsinPIxLUT(vectorSinCos.Angle, (int16_t *)&mcgenSineTable256))/32768.0;
// vectorSinCos.cos = ((float)mcsinPIxLUT((vectorSinCos.Angle + ANGLE_PI_DIVIDE_2_F16),(int16_t *)&mcgenSineTable256))/32768.0;
vectorU2ph.Alfa = _IQmpy(vectorUdq.d,vectorSinCos.cos) - _IQmpy(vectorUdq.q,vectorSinCos.sin);
vectorU2ph.Beta = _IQmpy(vectorUdq.q,vectorSinCos.cos) + _IQmpy(vectorUdq.d,vectorSinCos.sin);
temp1= vectorU2ph.Beta;
temp2= _IQdiv2(vectorU2ph.Beta) + (_IQmpy(_IQ(0.866),vectorU2ph.Alfa));
temp3= temp2 - temp1;
@ -126,6 +195,8 @@ void vector_inversion(void)
VecSector=(temp3> 0)?( VecSector-1):VecSector;
VecSector=(temp1< 0)?(7-VecSector) :VecSector;
if (VecSector==1 || VecSector==4)
{
vectorUabc.a= temp2;
@ -144,12 +215,11 @@ void vector_inversion(void)
vectorUabc.b=-temp3;
vectorUabc.c=-(temp1+temp2);
}
pwm_set_volt_3F(vectorUabc.a,vectorUabc.b,vectorUabc.c);
pwm_set_volt_3F(vectorUabc.a,vectorUabc.b,vectorUabc.c);
}
float Test1, Test2;
float FRM_Ud, FRM_Uq;
void vector_klark_park(uint16_t SectorOn, int16_t CurrentA, int16_t CurrentB, int16_t CurrentC)
{
@ -203,14 +273,19 @@ void vector_klark_park(uint16_t SectorOn, int16_t CurrentA, int16_t CurrentB, in
vectorI2ph.Alfa = vectorIabc.a;
vectorI2ph.Beta = _IQmpy((vectorIabc.a +_IQmpy2(vectorIabc.b)),_IQ(ONEbySQRT3)); //vectorI2ph.Beta = _IQmpy((vectorIabc.b - vectorIabc.c),_IQ(ONEbySQRT3));
vectorSinCos.sin = ((float)vector_mcsinPIxLUT(vectorSinCos.Angle, (int16_t *)&mcgenSineTable256))/32768.0;
vectorSinCos.cos = ((float)vector_mcsinPIxLUT((vectorSinCos.Angle + ANGLE_PI_DIVIDE_2_F16),(int16_t *)&mcgenSineTable256))/32768.0;
sin_int = vector_mcsinPIxLUT(vectorSinCos.Angle, (int16_t *)&mcgenSineTable256);
cos_int = vector_mcsinPIxLUT((vectorSinCos.Angle + ANGLE_PI_DIVIDE_2_F16),(int16_t *)&mcgenSineTable256);
vectorSinCos.sin = ((float)sin_int)/32768.0;
vectorSinCos.cos = ((float)cos_int)/32768.0;
// ïðåîáðàçîâàíèå Ïàðêà
vectorIdq.d = _IQmpy(vectorI2ph.Alfa,vectorSinCos.cos) + _IQmpy(vectorI2ph.Beta,vectorSinCos.sin);
vectorIdq.q = _IQmpy(vectorI2ph.Beta,vectorSinCos.cos) - _IQmpy(vectorI2ph.Alfa,vectorSinCos.sin);
Gpio55out(1);
Angle_test = Atan(sin_int, cos_int);
Gpio55out(0);
// CurrLoop.piIq.Ref = Inputs->IqRef;//Çàäàííîå
@ -222,7 +297,7 @@ void vector_klark_park(uint16_t SectorOn, int16_t CurrentA, int16_t CurrentB, in
CurrLoop.piIq.Fbk = vectorIdq.q;
CurrLoop.piId.Ref = 0;
// CurrLoop.piId.Ref = 0;
CurrLoop.piId.Fbk = vectorIdq.d;
// CurrLoop.piId.Umax = CurrLoop.piIq.Umax = Inputs->Udc;
@ -236,25 +311,30 @@ void vector_klark_park(uint16_t SectorOn, int16_t CurrentA, int16_t CurrentB, in
CurrLoop.piId.uCorr = CurrLoop.piIq.uCorr = 0.0f;
#endif
PI_MACRO(CurrLoop.piId);
PI_MACRO(CurrLoop.piIq);
PI_MACRO(CurrLoop.piId);
/*Ïðîïîðöèîíàëüíîå îãðàíè÷åíèå íàïðÿæåíèé Uq è Ud*/
// Test1 = my_sqrtf(Test2);
float Ulim = my_sqrtf(CurrLoop.piId.Out * CurrLoop.piId.Out + CurrLoop.piIq.Out * CurrLoop.piIq.Out);
if (Ulim > VOLT_MAX_PROC)
{
if(Ulim > ZERO_LVL)
{
float K = VOLT_MAX_PROC / Ulim;
CurrLoop.piId.Out *= K;
CurrLoop.piIq.Out *= K;
}
if(Ulim > ZERO_LVL)
{
float K = VOLT_MAX_PROC / Ulim;
FRM_Ud = CurrLoop.piId.Out *= K;
FRM_Uq = CurrLoop.piIq.Out *= K;
}
}
if(!NoLoop)
{
vectorUdq.q = CurrLoop.piIq.Out;
vectorUdq.d = CurrLoop.piId.Out;
}
// vectorUdq.q = CurrLoop.piIq.Out;
// vectorUdq.d = CurrLoop.piId.Out;
}
float my_sqrtf(float x)

22
Projects/epwm_test/src/vector.h
View File

@ -33,11 +33,11 @@
#define SIN_INDEX_SHIFT 6
#define SIN_LENGTH_TABLE 256
#define VOLT_MAX_PROC PWM_MAX
#define PI_REG_I_PROPOR 0
#define PI_REG_I_INTEGR 0
#define VOLT_MAX_PROC 94.0
#define PI_REG_I_PROPOR 35.0
#define PI_REG_I_INTEGR 0.1
#define CURRENT_MAX 40.0 //A
#define ZERO_LVL 0.000001f
#define ZERO_LVL 0.00001f
typedef struct
{
@ -73,12 +73,24 @@ typedef struct
PI_CONTROLLER piId;
}TvectorCurrentLoop;
typedef enum
{
OffMode, //Ěîňîđ îńňŕíîâëĺí
StepMode, //
StayMode,
CurrentRegTune,
VectorModeU,
VectorModeI
}TMode;
int16_t vector_mcsinPIxLUT(int16_t Value, int16_t *psinTable);
void vector_inversion(void);
void vector_klark_park(uint16_t SectorOn, int16_t CurrentA, int16_t CurrentB, int16_t CurrentC);
void vector_set_angle(int16_t val);
void vectorInitCurrLoop(void);
void vectorControl(int16_t CurrentA, int16_t CurrentB, int16_t CurrentC);
void vectorFault(void);
float my_sqrtf(float x);
void vectorResCurrLoop(void);
#endif /* SRC_VECTOR_H_ */

BIN
Projects/epwm_test/Безымянный.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB