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

SDFM-PWM FLT заготовка

Browse Source
This commit is contained in:
seklyuts 2024-08-29 16:55:31 +03:00
parent 6a5ba6fd4f
commit b4bbe14b67
19 changed files with 405 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Projects/epwm_test_biss_c_cpu1/src/Peripherals/gpio_init.c
View File

@ -73,6 +73,8 @@ void GpioSetOrange(void)
void GpioInit(void)
{
EALLOW;

39
Projects/epwm_test_biss_c_cpu1/src/Peripherals/pwm_init.h
View File

@ -1,7 +1,7 @@
/*
* pwm_init.h
*
* Created on: 21 ŕâă. 2023 ă.
* Created on: 21 <EFBFBD><EFBFBD><EFBFBD>. 2023 <EFBFBD>.
* Author: seklyuts
*/
#include "f28x_project.h"
@ -14,28 +14,51 @@
#define FREQUENCY_BRAKE 200000.0 //Hz
#define FREQUENCY_MOTOR 10000.0 //Hz
#define EPWM_DB_mkS 3.0 //mkS
#define EPWM_DB_mkS 4.0 //mkS
#define FREQUENCY_FAN 1000.0 //Hz
#define PERIOD_FAN (SYS_PWM_FREQUENCY/2.0/FREQUENCY_FAN)
#define PERIOD_BRAKE (SYS_PWM_FREQUENCY/2.0/FREQUENCY_BRAKE) //Tic
#define PERIOD_MOTOR (SYS_PWM_FREQUENCY/2.0/FREQUENCY_MOTOR) //Tic
#define PERIOD_MOTOR (SYS_PWM_FREQUENCY/2.0/FREQUENCY_MOTOR) //Tic = 5000
#define EPWM_DB (EPWM_DB_mkS*SYS_PWM_FREQUENCY/1000000)
#define SDFM_DELAY_mkS 50.0 //mkS
#define SDFM_DELAY (SDFM_DELAY_mkS*SYS_PWM_FREQUENCY/1000000)
#define PERIOD_2 (PERIOD_MOTOR/2.0)
#define PWM_MAX (PERIOD_MOTOR - EPWM_DB)
#define PWM_MIN EPWM_DB*2
#define PERIOD_DIV2 (PERIOD_MOTOR/2.0)
#define PERIOD_MAX (PERIOD_MOTOR*1.25)
//#define PWM_MAX (PERIOD_MOTOR - EPWM_DB)
//#define PWM_MIN EPWM_DB*2
#define INDEPENDED 1
#define COMPLIMENTARY 0
#ifdef REF0
#define PWM_A 5
#define PWM_B 2
#define PWM_C 7
#define PWM_FAN 3
#define PWM_BRAKE 8
#define PWM_BASE_TIMER 1
#else
#define PWM_A 5
#define PWM_B 4
#define PWM_C 2
#define PWM_FAN 3
#define PWM_BRAKE 8
#define PWM_BASE_TIMER 1
#endif
void PWMInit(uint16_t Num, uint16_t Period, uint16_t Independed);
void PWMGpioInit(void);
void PWMInitEnable(void);
@ -43,7 +66,7 @@ void PWMInitInterruptEn(void);
void PWMAllInit(void);
void PWM_ABC_StopAllClose(void);
void PWM_ABC_StartOut(void);
void PWM_ABC_Start(uint16_t Num);
void InitEPwm1Example(void);
void InitEPwm2Example(void);

26
Projects/epwm_test_biss_c_cpu1/src/Peripherals/pwm_interrupts.c
View File

@ -35,7 +35,7 @@ typedef struct
int16_t UC;
}strPWMABC;
volatile strPWMABC PWM_motor = {PERIOD_2, PERIOD_2, PERIOD_2};
volatile strPWMABC PWM_motor = {PERIOD_DIV2, PERIOD_DIV2, PERIOD_DIV2};
int16_t A_proc,B_proc,C_proc;
uint16_t PWM_Vent = PERIOD_MOTOR;
@ -44,9 +44,9 @@ uint16_t PWM_Chop = 0;
void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC, float Udc)
{
A_proc = (int16_t)((phaseA/Udc)*PERIOD_2);
B_proc = (int16_t)((phaseB/Udc)*PERIOD_2);
C_proc = (int16_t)((phaseC/Udc)*PERIOD_2);
A_proc = (int16_t)((phaseA/Udc)*PERIOD_DIV2);
B_proc = (int16_t)((phaseB/Udc)*PERIOD_DIV2);
C_proc = (int16_t)((phaseC/Udc)*PERIOD_DIV2);
if(A_proc > 0) A_proc+= EPWM_DB/2;
else if(A_proc < 0) A_proc-= EPWM_DB/2;
@ -55,9 +55,9 @@ void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC, float Udc)
if(C_proc > 0) C_proc+= EPWM_DB/2;
else if(C_proc < 0) C_proc-= EPWM_DB/2;
PWM_motor.UA = PERIOD_2 + A_proc;
PWM_motor.UB = PERIOD_2 + B_proc;
PWM_motor.UC = PERIOD_2 - C_proc;
PWM_motor.UA = PERIOD_DIV2 + A_proc;
PWM_motor.UB = PERIOD_DIV2 + B_proc;
PWM_motor.UC = PERIOD_DIV2 - C_proc;
FaultABC = 0;//(FaultPWM);
if(FaultABC) FaultABCFix = FaultABC;
@ -65,9 +65,9 @@ void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC, float Udc)
if((FaultABC)||(FaultABCFix))
{
PWM_ABC_StopAllClose();
PWM_motor.UA = PERIOD_2;
PWM_motor.UB = PERIOD_2;
PWM_motor.UC = PERIOD_2;
PWM_motor.UA = PERIOD_DIV2;
PWM_motor.UB = PERIOD_DIV2;
PWM_motor.UC = PERIOD_DIV2;
vectorFault();
}
@ -132,9 +132,9 @@ __interrupt void epwm2_isr(void)
AdcStartSet();
BissStartSet();
PWM_ABC_StopAllClose();
PWM_motor.UA = PERIOD_2;
PWM_motor.UB = PERIOD_2;
PWM_motor.UC = PERIOD_2;
PWM_motor.UA = PERIOD_DIV2;
PWM_motor.UB = PERIOD_DIV2;
PWM_motor.UC = PERIOD_DIV2;
vectorFault();
EPwmRegs[3]->CMPA.bit.CMPA = PERIOD_MOTOR - PWM_Vent;
EPwmRegs[3]->CMPB.bit.CMPB = PERIOD_MOTOR - PWM_Chop;

3
Projects/epwm_test_biss_c_cpu1/src/init_perif.c
View File

@ -17,6 +17,7 @@
#include "i2c_init.h"
#include "spi_init.h"
#include "biss.h"
#include "sdfm_pwm_xbar.h"
#define TO_CPU1 0
@ -116,7 +117,7 @@ void InitPerif(void)
SpiCGpioInit();
BissGpioInit();
BissInit();
sdfm_pwm_xbarInit();
// ConfigureADC();

BIN
Projects/epwm_test_biss_c_cpu2/Start_rfm.pmp
View File

Binary file not shown.

2
Projects/epwm_test_biss_c_cpu2/src/ExternalEEPROM/BL25CM1A.c
View File

@ -230,7 +230,7 @@ void Bl25cm1a_write_data(uint32_t Addr_8bit, uint16_t quant_8bit, uint16_t * wri
while( (Addr_8bit&0xFF)+(quant_8bit) > BL25CM1A0_PAGE) //åñëè äàííûå âûõîäÿò çà ãðàíèöó òåêóùåé ñòðàíèöû
{
page_quant_8bit = BL25CM1A0_PAGE - (Addr_8bit&0xFF); //âû÷èñëÿåì êîë-âî áàéò äàííûõ äî êîíöà òåêóùåé ñòðàíèöû
Bl25cm1a_write_1_page(Addr_8bit, page_quant_8bit/2, addr_write_data); //çàïèñûâàåì ýòè äàííûå íà òåêóùóþ ñòðàíèöó
Bl25cm1a_write_1_page(Addr_8bit, page_quant_8bit, addr_write_data); //çàïèñûâàåì ýòè äàííûå íà òåêóùóþ ñòðàíèöó
Addr_8bit += page_quant_8bit; //ïåðåëèñòûâàåì ñòðàíèöó âíåøíåé ïàìÿòè
addr_write_data += page_quant_8bit/2; //øàãàåì íà ñëåäóþùèå íåçàïèñàííûå äàííûå â áóôåðå
quant_8bit -= page_quant_8bit; //óìåíüøàåì êîë-âî äàííûõ íà âåëè÷èíó êîòîðóþ óæå çàïèñàëè

223
Projects/epwm_test_biss_c_cpu2/src/ExternalEEPROM/GD25Q16ETIGR.c
View File

@ -1,7 +1,7 @@
/*
* GD25Q16ETIGR.c
*
* Created on: 7 ñåíò. 2023 ã.
* Created on: 7 сент. 2023 г.
* Author: seklyuts
*/
#include "f28x_project.h"
@ -29,15 +29,27 @@ uint16_t GD25Q16ETIGR_buffer8bytes[8];
uint16_t SectorWasErraised[512];
uint16_t writeVerify = 1;
uint16_t GD25Q16ETIGR_Sektor_Addr(uint32_t Addr)
void delay(void)
{
uint16_t sektor;
for (sektor=1; sektor <= 512; sektor++ )
uint32_t i;
for(i=0;i<100000;i++)
{
if(Addr < (0x1000*sektor)) return sektor-1;
asm (" NOP");
}
}
void GD25Q16ETIGR_checkRXFFST(void)
{
volatile uint16_t empty;
while(SpiRegs.SPIFFRX.bit.RXFFST > 0)
{
empty = SpiRegs.SPIRXBUF;
}
return 511;
}
@ -54,6 +66,7 @@ void GD25Q16ETIGR_clean_SectorWasErraised(void)
void GD25Q16ETIGR_en(void)
{
volatile uint16_t empty;
// GD25Q16ETIGR_checkRXFFST();
transmitData(WriteEnable);
while(SpiRegs.SPIFFRX.bit.RXFFST != 1)
{
@ -65,6 +78,7 @@ void GD25Q16ETIGR_en(void)
uint16_t GD25Q16ETIGR_ReadStatus(void)
{
volatile uint16_t empty;
// GD25Q16ETIGR_checkRXFFST();
transmitData(ReadStatusRegister1);
transmitData(0xFF);
while(SpiRegs.SPIFFRX.bit.RXFFST != 2)
@ -76,18 +90,37 @@ uint16_t GD25Q16ETIGR_ReadStatus(void)
return empty;
}
void GD25Q16ETIGR_sector_erase(uint32_t Addr)
volatile uint32_t MaxRepeat = 0;
uint16_t GD25Q16ETIGR_WaitStatus(void)
{
volatile uint16_t empty;
uint16_t repeat = 0, ErrRepeat = 0x4000;
uint16_t Stat = 1;
Stat = GD25Q16ETIGR_ReadStatus();
while((Stat&0x1) != 0 )
{
Stat = GD25Q16ETIGR_ReadStatus();
repeat++;
if(repeat > ErrRepeat) return 1;
}
if(repeat > MaxRepeat) MaxRepeat = repeat;
return 0;
}
uint16_t GD25Q16ETIGR_sector_erase(uint32_t Addr)
{
volatile uint16_t empty;
uint16_t Err = 0;
GD25Q16ETIGR_en();
Err = GD25Q16ETIGR_WaitStatus();
if(Err) return Err;
GD25Q16ETIGR_en();
// GD25Q16ETIGR_checkRXFFST();
transmitData(SectorErase);
transmitData(Addr>>16);
transmitData(Addr>>8);
@ -100,18 +133,19 @@ void GD25Q16ETIGR_sector_erase(uint32_t Addr)
empty = SpiRegs.SPIRXBUF;
empty = SpiRegs.SPIRXBUF;
empty = SpiRegs.SPIRXBUF;
return 0;
}
void GD25Q16ETIGR_read_8_bytes(uint32_t Addr, uint16_t * read_data, uint16_t num_byte)//÷òåíèå äî 8 áàéò
uint16_t GD25Q16ETIGR_read_8_bytes(uint32_t Addr, uint16_t * read_data, uint16_t num_byte)//чтение до 8 байт
{
volatile uint16_t empty, i, j;
uint16_t Stat = 1;
Stat = GD25Q16ETIGR_ReadStatus();
while((Stat&0x1) != 0 )
{
Stat = GD25Q16ETIGR_ReadStatus();
}
uint16_t Err = 0;
Err = GD25Q16ETIGR_WaitStatus();
if(Err) return Err;
// GD25Q16ETIGR_checkRXFFST();
transmitData(ReadData);
transmitData(Addr>>16);
@ -130,18 +164,19 @@ void GD25Q16ETIGR_read_8_bytes(uint32_t Addr, uint16_t * read_data, uint16_t num
{
read_data[j] = SpiRegs.SPIRXBUF;
}
return 0;
}
uint16_t GD25Q16ETIGR_verify_8_bytes(uint32_t Addr, uint16_t * verify_data, uint16_t num_byte)//÷òåíèå è ïðîâåðêà äî 8 áàéò
uint16_t GD25Q16ETIGR_verify_8_bytes(uint32_t Addr, uint16_t * verify_data, uint16_t num_byte)//чтение и проверка до 8 байт
{
volatile uint16_t empty, i, j;
uint16_t Stat = 1;
Stat = GD25Q16ETIGR_ReadStatus();
while((Stat&0x1) != 0 )
{
Stat = GD25Q16ETIGR_ReadStatus();
}
uint16_t Err = 0;
Err = GD25Q16ETIGR_WaitStatus();
if(Err) return Err;
// GD25Q16ETIGR_checkRXFFST();
transmitData(ReadData);
transmitData(Addr>>16);
@ -158,23 +193,33 @@ uint16_t GD25Q16ETIGR_verify_8_bytes(uint32_t Addr, uint16_t * verify_data, uint
empty = SpiRegs.SPIRXBUF;
for(j = 0; j<num_byte; j++)
{
if(verify_data[j] != SpiRegs.SPIRXBUF) return 1;
if(verify_data[j] != SpiRegs.SPIRXBUF) Err++;
}
return 0;
// GD25Q16ETIGR_checkRXFFST();
return Err;
}
void GD25Q16ETIGR_write_8_bytes(uint32_t Addr, uint16_t * write_data, uint16_t num_byte)//çàïèñü äî 8 áàéò
uint16_t GD25Q16ETIGR_write_8_bytes(uint32_t Addr, uint16_t * write_data, uint16_t num_byte)//запись до 8 байт
{
volatile uint16_t empty, i, j;
uint16_t Stat = 1;
Stat = GD25Q16ETIGR_ReadStatus();
while((Stat&0x1) != 0 )
{
Stat = GD25Q16ETIGR_ReadStatus();
}
uint16_t Err = 0;
GD25Q16ETIGR_en();
Err = GD25Q16ETIGR_WaitStatus();
if(Err) return Err;
GD25Q16ETIGR_en();
// GD25Q16ETIGR_checkRXFFST();
transmitData(PageProgram);
transmitData(Addr>>16);
transmitData(Addr>>8);
@ -192,28 +237,83 @@ void GD25Q16ETIGR_write_8_bytes(uint32_t Addr, uint16_t * write_data, uint16_t n
{
empty = SpiRegs.SPIRXBUF;
}
return 0;
}
void GD25Q16ETIGR_read_data(uint32_t Addr, uint16_t quant8, uint16_t * read_data)
uint32_t ErrAdr[8];// адреса неисправных байтов, которые не удалось записать даже повторно.
uint32_t CounterOfFixedError = 0;
uint32_t CounterOfTotalError = 0;
uint16_t GD25Q16ETIGR_write_veryfy_8_bytes(uint32_t Addr, uint16_t * write_data, uint16_t num_byte)//запись и проверка до 8 байт
{
uint16_t addr_write_data[8];
uint16_t addr_read_data[8];
uint16_t i, Err = 0, DoneOK = 0;
for(i = 0; i<num_byte; i++)
{
addr_write_data[i] = write_data[i];
}
Err = GD25Q16ETIGR_write_8_bytes(Addr, addr_write_data, num_byte);
if(Err) return Err;
Err = GD25Q16ETIGR_read_8_bytes(Addr, addr_read_data, num_byte);
if(Err) return Err;
for(i = 0; i<num_byte; i++)
{
if(addr_write_data[i] == addr_read_data[i])
{
DoneOK++;
}
else
{
Err = GD25Q16ETIGR_write_8_bytes(Addr+i, addr_write_data+i, 1);
if(Err) return Err;
Err = GD25Q16ETIGR_read_8_bytes(Addr, addr_read_data, num_byte);
if(Err) return Err;
if(addr_write_data[i] == addr_read_data[i])
{
DoneOK++;
CounterOfFixedError++;
}
else
{
ErrAdr[Err] = Addr+i;
CounterOfTotalError++;
}
}
}
return 0;
}
uint16_t GD25Q16ETIGR_read_data(uint32_t Addr, uint16_t quant8, uint16_t * read_data)
{
uint32_t i=0;
uint16_t addr_read_data[8];
uint16_t Err = 0;
if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{//â ýòîì öèêëå òîëüêî ïîëíûå ïîñûëêè ïî 8 áàéò
GD25Q16ETIGR_read_8_bytes(Addr+i, addr_read_data, 8);
{//в этом цикле только полные посылки по 8 байт
Err = GD25Q16ETIGR_read_8_bytes(Addr+i, addr_read_data, 8);
if(Err) return Err;
copy8_to_16(addr_read_data, read_data, 4);
read_data+=4;
}
}
if(i < quant8)
{//òóò ì.á. îò 1 äî 8 áàéò
GD25Q16ETIGR_read_8_bytes(Addr+i, addr_read_data, (quant8 - i));
if((quant8 - i) & 1) {addr_read_data[quant8] = 0; quant8++; }//åñëè áàéò íå÷¸òíîå ÷èñëî, òî äîïîëíÿåì äî ÷¸òíîãî íóë¸ì
{//тут м.б. от 1 до 8 байт
Err = GD25Q16ETIGR_read_8_bytes(Addr+i, addr_read_data, (quant8 - i));
if(Err) return Err;
if((quant8 - i) & 1) {addr_read_data[quant8] = 0; quant8++; }//если байт нечётное число, то дополняем до чётного нулём
copy8_to_16(addr_read_data, read_data, (quant8 - i)/2);
}
return 0;
}
@ -226,14 +326,14 @@ uint16_t GD25Q16ETIGR_verify_data(uint32_t Addr, uint16_t quant8, uint16_t * ver
if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{//â ýòîì öèêëå òîëüêî ïîëíûå ïîñûëêè ïî 8 áàéò
{//в этом цикле только полные посылки по 8 байт
copy16_to_8(verify_data, addr_vfy_data, 4);
if(GD25Q16ETIGR_verify_8_bytes(Addr+i, addr_vfy_data, 8)) return 1;
verify_data+=4;
}
}
if(i < quant8)
{//òóò ì.á. îò 1 äî 8 áàéò
{//тут м.б. от 1 до 8 байт
quant16 = quant16bitWords(quant8-i);
copy16_to_8(verify_data, addr_vfy_data, quant16);
if(GD25Q16ETIGR_verify_8_bytes(Addr+i, addr_vfy_data, (quant8 - i))) return 1;
@ -241,57 +341,67 @@ uint16_t GD25Q16ETIGR_verify_data(uint32_t Addr, uint16_t quant8, uint16_t * ver
return 0;
}
void GD25Q16ETIGR_write_1_page(uint32_t Addr, uint16_t quant8, uint16_t * write_data) // çàïèñü âíóòðè îäíîé ñòðàíèöû
uint16_t GD25Q16ETIGR_write_1_page(uint32_t Addr, uint16_t quant8, uint16_t * write_data) // запись внутри одной страницы
{
uint32_t i=0;
uint16_t addr_write_data[8];
uint16_t quant16;
uint16_t Err = 0;
if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{ //â ýòîì öèêëå òîëüêî ïîëíûå ïîñûëêè ïî 8 áàéò
{ //в этом цикле только полные посылки по 8 байт
copy16_to_8(write_data, addr_write_data, 4);
GD25Q16ETIGR_write_8_bytes(Addr+i, addr_write_data, 8);
if(!writeVerify) Err = GD25Q16ETIGR_write_8_bytes(Addr+i, addr_write_data, 8);
else Err = GD25Q16ETIGR_write_veryfy_8_bytes(Addr+i, addr_write_data, 8);
if(Err) return Err;
write_data += 4;
}
}
if(i < quant8)
{//òóò ì.á. îò 1 äî 8 áàéò
{//тут м.б. от 1 до 8 байт
quant16 = quant16bitWords(quant8-i);
copy16_to_8(write_data, addr_write_data, quant16);
GD25Q16ETIGR_write_8_bytes(Addr+i, addr_write_data, (quant8 - i));
if(!writeVerify) Err = GD25Q16ETIGR_write_8_bytes(Addr+i, addr_write_data, (quant8 - i));
else Err = GD25Q16ETIGR_write_veryfy_8_bytes(Addr+i, addr_write_data, (quant8 - i));
if(Err) return Err;
}
return 0;
}
void GD25Q16ETIGR_write_data(uint32_t Addr_8bit, uint16_t quant_8bit, uint16_t * write_data)
uint16_t GD25Q16ETIGR_write_data(uint32_t Addr_8bit, uint16_t quant_8bit, uint16_t * write_data)
{
uint16_t * addr_write_data = write_data;
uint16_t page_quant_8bit = 0;
uint16_t FlashSektorStart = 0;
uint16_t FlashSektorEnd = 0;
uint16_t i=0;
uint16_t Err = 0;
FlashSektorStart = GD25Q16ETIGR_Sektor_Addr(Addr_8bit); //ñåêòîð ñ êîòîðîãî íà÷èíàåòñÿ çàïèñü
FlashSektorEnd = GD25Q16ETIGR_Sektor_Addr(Addr_8bit + quant_8bit - 1); //ñåêòîð â êîòîðîì êîíåö çàïèñè
FlashSektorStart = (Addr_8bit)>>12; //сектор с которого начинается запись
FlashSektorEnd = (Addr_8bit + quant_8bit - 1)>>12; //сектор в котором конец записи
for(i = FlashSektorStart; i <= FlashSektorEnd; i++)
{
if(!SectorWasErraised[i]) {SectorWasErraised[i] = 1; GD25Q16ETIGR_sector_erase(i*0x1000);}
if(!SectorWasErraised[i]) {SectorWasErraised[i] = 1; Err = GD25Q16ETIGR_sector_erase((uint32_t)i*0x1000); if(Err) return Err;}
}
while( (Addr_8bit&0xFF)+(quant_8bit) > GD25Q16E_PAGE) //åñëè äàííûå âûõîäÿò çà ãðàíèöó òåêóùåé ñòðàíèöû
while( (Addr_8bit&0xFF)+(quant_8bit) > GD25Q16E_PAGE) //если данные выходят за границу текущей страницы
{
page_quant_8bit = GD25Q16E_PAGE - (Addr_8bit&0xFF); //âû÷èñëÿåì êîë-âî áàéò äàííûõ äî êîíöà òåêóùåé ñòðàíèöû
GD25Q16ETIGR_write_1_page(Addr_8bit, page_quant_8bit/2, addr_write_data); //çàïèñûâàåì ýòè äàííûå íà òåêóùóþ ñòðàíèöó
Addr_8bit += page_quant_8bit; //ïåðåëèñòûâàåì ñòðàíèöó âíåøíåé ïàìÿòè
addr_write_data += page_quant_8bit/2; //øàãàåì íà ñëåäóþùèå íåçàïèñàííûå äàííûå â áóôåðå (îíè ó íàñ 16-áèòíûìè ñëîâàìè)
quant_8bit -= page_quant_8bit; //óìåíüøàåì êîë-âî äàííûõ íà âåëè÷èíó êîòîðóþ óæå çàïèñàëè
page_quant_8bit = GD25Q16E_PAGE - (Addr_8bit&0xFF); //вычисляем кол-во байт данных до конца текущей страницы
Err = GD25Q16ETIGR_write_1_page(Addr_8bit, page_quant_8bit, addr_write_data); //записываем эти данные на текущую страницу
if(Err) return Err;
Addr_8bit += page_quant_8bit; //перелистываем страницу внешней памяти
addr_write_data += page_quant_8bit/2; //шагаем на следующие незаписанные данные в буфере (они у нас 16-битными словами)
quant_8bit -= page_quant_8bit; //уменьшаем кол-во данных на величину которую уже записали
}
if(quant_8bit > 0)
{
GD25Q16ETIGR_write_1_page(Addr_8bit, quant_8bit, addr_write_data); //åñëè äàííûå äëÿ çàïèñè îñòàëèñü, òî çàïèñûâàåì èõ
Err = GD25Q16ETIGR_write_1_page(Addr_8bit, quant_8bit, addr_write_data); //если данные для записи остались, то записываем их
if(Err) return Err;
}
return 0;
}
@ -300,6 +410,9 @@ void GD25Q16ETIGR_write_data(uint32_t Addr_8bit, uint16_t quant_8bit, uint16_t *
uint16_t GD25Q16ETIGR_ReadManufacturerDeviceID(void)
{
volatile uint16_t empty, i, j;
// GD25Q16ETIGR_checkRXFFST();
transmitData(ReadManufacturerDeviceID);
for(i = 0; i<5; i++) transmitData(0xFF);

4
Projects/epwm_test_biss_c_cpu2/src/ExternalEEPROM/GD25Q16ETIGR.h
View File

@ -13,8 +13,8 @@
void GD25Q16ETIGR_en(void);
void GD25Q16ETIGR_write(void);
void GD25Q16ETIGR_write_data(uint32_t Addr, uint16_t quant, uint16_t * write_data);
void GD25Q16ETIGR_read_data(uint32_t Addr, uint16_t quant, uint16_t * read_data);
uint16_t GD25Q16ETIGR_write_data(uint32_t Addr, uint16_t quant, uint16_t * write_data);
uint16_t GD25Q16ETIGR_read_data(uint32_t Addr, uint16_t quant, uint16_t * read_data);
uint16_t GD25Q16ETIGR_verify_data(uint32_t Addr, uint16_t quant, uint16_t * verify_data);
uint16_t GD25Q16ETIGR_ReadManufacturerDeviceID(void);
void GD25Q16ETIGR_clean_SectorWasErraised(void);

42
Projects/epwm_test_biss_c_cpu2/src/ExternalEEPROM/ZD24C02A.c
View File

@ -1,7 +1,7 @@
/*
* ZD24C02A.c
*
* Created on: 8 сент. 2023 г.
* Created on: 8 <EFBFBD><EFBFBD><EFBFBD><EFBFBD>. 2023 <EFBFBD>.
* Author: seklyuts
*/
#include "f28x_project.h"
@ -9,12 +9,12 @@
#include "ZD24C02A.h"
#include "Arr.h"
//Нуждается в проверке и отладке, так как с этой микросхемой не удалось добиться стабильной работы, она то работает, то нет
volatile uint16_t SlaveAdr = I2C_SLAVE_ADDRESS;
volatile uint16_t SlaveAdr = I2C_SLAVE_ADDRESS1;
uint16_t BufferZD24C02A[17];
uint16_t ZD24C02A_write_8(uint16_t Addr, uint16_t * Array, uint16_t quant)// может писать очередями по 16 байт
uint16_t ZD24C02A_write_8(uint16_t Addr, uint16_t * Array, uint16_t quant)// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 16 <20><><EFBFBD><EFBFBD>
{
if(I2CWrite(SlaveAdr, Addr, quant, true, Array)) return 1;
else return 0;
@ -41,24 +41,33 @@ uint16_t ZD24C02A_verify_8(uint16_t Addr, uint16_t * Array, uint16_t quant)
uint16_t ZD24C02A_write(uint32_t Addr, uint16_t quant8, uint16_t * write_data)
{
uint32_t i=0;
uint16_t addr_write_data[8];
uint16_t addr_write_data[0x100];
uint16_t quant16;
if(quant8 > 8)
quant16 = quant16bitWords(quant8);
copy16_to_8(write_data, addr_write_data, quant16);
for(i = 0; i < quant8; i += 1)
{
if( ZD24C02A_write_8(Addr+i, addr_write_data+i, 1)) return 1;
}
/* if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{//в этом цикле только полные посылки по 8 байт
{//<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 8 <20><><EFBFBD><EFBFBD>
copy16_to_8(write_data, addr_write_data, 4);
if( ZD24C02A_write_8(Addr+i, addr_write_data, 8)) return 1;
write_data += 4;
}
}
if(i < quant8)
{//тут м.б. от 1 до 8 байт
{//<EFBFBD><EFBFBD><EFBFBD> <20>.<2E>. <20><> 1 <20><> 8 <20><><EFBFBD><EFBFBD>
quant16 = quant16bitWords(quant8-i);
copy16_to_8(write_data, addr_write_data, quant16);
if( ZD24C02A_write_8(Addr+i, addr_write_data, (quant8 - i))) return 1;
}
*/
return 0;
}
@ -70,16 +79,16 @@ uint16_t ZD24C02A_read(uint32_t Addr, uint16_t quant8, uint16_t * read_data)
if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{//в этом цикле только полные посылки по 8 байт
{//<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 8 <20><><EFBFBD><EFBFBD>
if( ZD24C02A_read_8(Addr+i, addr_read_data, 8)) return 1;
copy8_to_16(addr_read_data, read_data, 4);
read_data+=4;
}
}
if(i < quant8)
{//тут м.б. от 1 до 8 байт
{//<EFBFBD><EFBFBD><EFBFBD> <20>.<2E>. <20><> 1 <20><> 8 <20><><EFBFBD><EFBFBD>
if( ZD24C02A_read_8(Addr+i, addr_read_data, (quant8 - i))) return 1;
if((quant8 - i) & 1) {addr_read_data[quant8] = 0; quant8++; }//если байт нечётное число, то дополняем до чётного нулём
if((quant8 - i) & 1) {addr_read_data[quant8] = 0; quant8++; }//<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
copy8_to_16(addr_read_data, read_data, (quant8 - i)/2);
}
return 0;
@ -95,7 +104,7 @@ uint16_t ZD24C02A_verify(uint32_t Addr, uint16_t quant8, uint16_t * verify_data)
if(quant8 > 8)
{
for(i = 0; i < (quant8-8); i += 8)
{//в этом цикле только полные посылки по 8 байт
{//<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 8 <20><><EFBFBD><EFBFBD>
copy16_to_8(verify_data, addr_vfy_data, 4);
Err_read = ZD24C02A_verify_8(Addr+i, addr_vfy_data, 8);
if(Err_read) return Err_read;
@ -103,22 +112,17 @@ uint16_t ZD24C02A_verify(uint32_t Addr, uint16_t quant8, uint16_t * verify_data)
}
}
if(i < quant8)
{//тут м.б. от 1 до 8 байт
{//<EFBFBD><EFBFBD><EFBFBD> <20>.<2E>. <20><> 1 <20><> 8 <20><><EFBFBD><EFBFBD>
quant16 = quant16bitWords(quant8-i);
copy16_to_8(verify_data, addr_vfy_data, quant16);
Err_read = ZD24C02A_verify_8(Addr+i, addr_vfy_data, (quant8 - i));
if(Err_read) return Err_read;
}
return 0;
return 0;// 0 - DONE_SUCCESS ; 1 - FLASH_ERR; 2 - ERROR_VERIFY
}
void ZD24C02A_read_all(uint16_t byteCount, uint16_t * Array)
{
I2CRead(SlaveAdr, byteCount, true, Array);

6
Projects/epwm_test_biss_c_cpu2/src/ExternalEEPROM/ZD24C02A.h
View File

@ -1,14 +1,16 @@
/*
* ZD24C02A.h
*
* Created on: 8 ñåíò. 2023 ã.
* Created on: 8 <EFBFBD><EFBFBD><EFBFBD><EFBFBD>. 2023 <EFBFBD>.
* Author: seklyuts
*/
#ifndef SRC_ZD24C02A_H_
#define SRC_ZD24C02A_H_
#define I2C_SLAVE_ADDRESS 0x51U
#define I2C_SLAVE_ADDRESS0 0x51U
#define I2C_SLAVE_ADDRESS1 0x50U
#define I2C_OWN_ADDRESS 0x30U
#define ZD24C02A_SIZE 0x80

9
Projects/epwm_test_biss_c_cpu2/src/Peripherals/pwm_init.c
View File

@ -82,6 +82,15 @@ void PWM_ABC_Start(uint16_t Num)
}
void PWMTripInit(void)
{
EALLOW;
EPwmRegs[PWM_A]->DCTRIPSEL.all = 0x3333;
EPwmRegs[PWM_B]->DCTRIPSEL.all = 0x3333;
EPwmRegs[PWM_C]->DCTRIPSEL.all = 0x3333;
EDIS;
}
void PWMAllInit(void)
{
//

5
Projects/epwm_test_biss_c_cpu2/src/Peripherals/pwm_init.h
View File

@ -28,7 +28,8 @@
#define SDFM_DELAY_mkS 50.0 //mkS
#define SDFM_DELAY (SDFM_DELAY_mkS*SYS_PWM_FREQUENCY/1000000)
#define PERIOD_2 (PERIOD_MOTOR/2.0)
#define PERIOD_DIV2 (PERIOD_MOTOR/2.0)
#define PERIOD_MAX (PERIOD_MOTOR*1.25)
//#define PWM_MAX (PERIOD_MOTOR - EPWM_DB)
//#define PWM_MIN EPWM_DB*2
#define INDEPENDED 1
@ -73,7 +74,7 @@ void InitEPwm3Example(void);
void InitEPwm4Example(void);
void InitEPwm5Example(void);
void InitEPwm6Example(void);
void PWMTripInit(void);

16
Projects/epwm_test_biss_c_cpu2/src/Peripherals/pwm_interrupts.c
View File

@ -5,7 +5,7 @@
* Author: seklyuts
*/
#include <pwm_init.h>
#include "f28x_project.h"
#include "frm_uart.h"
#include "gpio_init.h"
@ -39,8 +39,8 @@ typedef struct
volatile uint16_t PeriodPWM[2] = {PERIOD_MOTOR, PERIOD_MOTOR};
volatile uint16_t PeriodPWM_2 = PERIOD_2;
volatile strPWMABC PWM_motor = {PERIOD_2, PERIOD_2, PERIOD_2};
volatile uint16_t PeriodPWM_2 = PERIOD_DIV2;
volatile strPWMABC PWM_motor = {PERIOD_DIV2, PERIOD_DIV2, PERIOD_DIV2};
int16_t A_proc,B_proc,C_proc;
uint16_t PWM_Vent = PERIOD_FAN;
@ -55,8 +55,8 @@ void pwm_set_volt_3F(float phaseA, float phaseB, float phaseC, float Udc, uint16
{
if(Mode == OffMode)
{
if(PeriodPWM[0] < PERIOD_2) PeriodPWM[0]=PERIOD_2;
if(PeriodPWM[0] > PERIOD_MOTOR) PeriodPWM[0]=PERIOD_MOTOR;
if(PeriodPWM[0] < PERIOD_DIV2) PeriodPWM[0]=PERIOD_DIV2;
if(PeriodPWM[0] > PERIOD_MAX) PeriodPWM[0]=PERIOD_MAX;
PeriodPWM[1] = PeriodPWM[0];
vectorRegKoeffRecalc(PeriodPWM[0]/PERIOD_MOTOR);
EALLOW;
@ -168,9 +168,9 @@ __interrupt void epwm2_isr(void)
AdcStartSet();
BissStartSet();
PWM_ABC_StopAllClose();
PWM_motor.UA = PERIOD_2;
PWM_motor.UB = PERIOD_2;
PWM_motor.UC = PERIOD_2;
PWM_motor.UA = PERIOD_DIV2;
PWM_motor.UB = PERIOD_DIV2;
PWM_motor.UC = PERIOD_DIV2;
vectorFault();
EPwmRegs[PWM_FAN]->CMPA.bit.CMPA = PERIOD_MOTOR - PWM_Vent;
// EPwmRegs[3]->CMPB.bit.CMPB = PERIOD_MOTOR - PWM_Chop;

123
Projects/epwm_test_biss_c_cpu2/src/Peripherals/sdfm.c
View File

@ -193,7 +193,7 @@ void SdfmInitInterruptEn(void)
void SdfmInit(void)
{
uint16_t HLT, LLT;
uint16_t HLT, LLT, Max, Min;
//
// Configure SDFM type to 0
//
@ -213,7 +213,14 @@ void SdfmInit(void)
//
// Comparator Module
//
// стр 3210
// HLT1
//When comparator data > = (SDFLTxCMPH1.HLT), HLT1 comparator generates COMPH1 event.
//The COMPH1 event is connected to both CEVT1 and CEVT2.
//LLT1
//When comparator data < = (SDFLTxCMPL1.LLT), the LLT1 comparator generates COMPL1 event.
//The COMPL1 event is connected to both CEVT1 and CEVT2.
HLT = 0x7FFF; //Over value threshold settings
LLT = 0x0000; //Under value threshold settings
@ -304,8 +311,118 @@ void SdfmInit(void)
Sdfm2Regs.SDDFPARM3.bit.FEN = 1;
Sdfm2Regs.SDDFPARM4.bit.FEN = 1;
EDIS;
sdfmInitPwmFlt(SDFM_IA, Max, Min);
sdfmInitPwmFlt(SDFM_IB, Max, Min);
sdfmInitPwmFlt(SDFM_IC, Max, Min);
}
#define CEVT_interrupt_enable 0;
void sdfmInitPwmFlt(uint16_t N, uint16_t LowFLT, uint16_t HightFlt)
{
EALLOW;
switch(N)
{
case 0:
Sdfm1Regs.SDCPARM1.bit.CEVT1SEL = 1;
Sdfm1Regs.SDCPARM1.bit.CEVT2SEL = 1;
Sdfm1Regs.SDCOMP1CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm1Regs.SDCOMP1CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm1Regs.SDIFLGCLR.bit.FLT1_FLG_CEVT1 = 1;
Sdfm1Regs.SDIFLGCLR.bit.FLT1_FLG_CEVT2 = 1;
Sdfm1Regs.SDCPARM1.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm1Regs.SDCPARM1.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm1Regs.SDFLT1CMPH1.bit.HLT = HightFlt;
Sdfm1Regs.SDFLT1CMPL1.bit.LLT = LowFLT;
break;
case 1:
Sdfm1Regs.SDCPARM2.bit.CEVT1SEL = 1;
Sdfm1Regs.SDCPARM2.bit.CEVT2SEL = 1;
Sdfm1Regs.SDCOMP2CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm1Regs.SDCOMP2CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm1Regs.SDIFLGCLR.bit.FLT2_FLG_CEVT1 = 1;
Sdfm1Regs.SDIFLGCLR.bit.FLT2_FLG_CEVT2 = 1;
Sdfm1Regs.SDCPARM2.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm1Regs.SDCPARM2.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm1Regs.SDFLT2CMPH1.bit.HLT = HightFlt;
Sdfm1Regs.SDFLT2CMPL1.bit.LLT = LowFLT;
break;
case 2:
Sdfm1Regs.SDCPARM3.bit.CEVT1SEL = 1;
Sdfm1Regs.SDCPARM3.bit.CEVT2SEL = 1;
Sdfm1Regs.SDCOMP3CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm1Regs.SDCOMP3CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm1Regs.SDIFLGCLR.bit.FLT3_FLG_CEVT1 = 1;
Sdfm1Regs.SDIFLGCLR.bit.FLT3_FLG_CEVT2 = 1;
Sdfm1Regs.SDCPARM3.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm1Regs.SDCPARM3.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm1Regs.SDFLT3CMPH1.bit.HLT = HightFlt;
Sdfm1Regs.SDFLT3CMPL1.bit.LLT = LowFLT;
break;
case 3:
Sdfm1Regs.SDCPARM4.bit.CEVT1SEL = 1;
Sdfm1Regs.SDCPARM4.bit.CEVT2SEL = 1;
Sdfm1Regs.SDCOMP4CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm1Regs.SDCOMP4CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm1Regs.SDIFLGCLR.bit.FLT4_FLG_CEVT1 = 1;
Sdfm1Regs.SDIFLGCLR.bit.FLT4_FLG_CEVT2 = 1;
Sdfm1Regs.SDCPARM4.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm1Regs.SDCPARM4.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm1Regs.SDFLT4CMPH1.bit.HLT = HightFlt;
Sdfm1Regs.SDFLT4CMPL1.bit.LLT = LowFLT;
break;
case 4:
Sdfm2Regs.SDCPARM1.bit.CEVT1SEL = 1;
Sdfm2Regs.SDCPARM1.bit.CEVT2SEL = 1;
Sdfm2Regs.SDCOMP1CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm2Regs.SDCOMP1CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm2Regs.SDIFLGCLR.bit.FLT1_FLG_CEVT1 = 1;
Sdfm2Regs.SDIFLGCLR.bit.FLT1_FLG_CEVT2 = 1;
Sdfm2Regs.SDCPARM1.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm2Regs.SDCPARM1.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm2Regs.SDFLT1CMPH1.bit.HLT = HightFlt;
Sdfm2Regs.SDFLT1CMPL1.bit.LLT = LowFLT;
break;
case 5:
Sdfm2Regs.SDCPARM2.bit.CEVT1SEL = 1;
Sdfm2Regs.SDCPARM2.bit.CEVT2SEL = 1;
Sdfm2Regs.SDCOMP2CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm2Regs.SDCOMP2CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm2Regs.SDIFLGCLR.bit.FLT2_FLG_CEVT1 = 1;
Sdfm2Regs.SDIFLGCLR.bit.FLT2_FLG_CEVT2 = 1;
Sdfm2Regs.SDCPARM2.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm2Regs.SDCPARM2.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm2Regs.SDFLT2CMPH1.bit.HLT = HightFlt;
Sdfm2Regs.SDFLT2CMPL1.bit.LLT = LowFLT;
break;
case 6:
Sdfm2Regs.SDCPARM3.bit.CEVT1SEL = 1;
Sdfm2Regs.SDCPARM3.bit.CEVT2SEL = 1;
Sdfm2Regs.SDCOMP3CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm2Regs.SDCOMP3CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm2Regs.SDIFLGCLR.bit.FLT3_FLG_CEVT1 = 1;
Sdfm2Regs.SDIFLGCLR.bit.FLT3_FLG_CEVT2 = 1;
Sdfm2Regs.SDCPARM3.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm2Regs.SDCPARM3.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm2Regs.SDFLT3CMPH1.bit.HLT = HightFlt;
Sdfm2Regs.SDFLT3CMPL1.bit.LLT = LowFLT;
break;
case 7:
Sdfm2Regs.SDCPARM4.bit.CEVT1SEL = 1;
Sdfm2Regs.SDCPARM4.bit.CEVT2SEL = 1;
Sdfm2Regs.SDCOMP4CTL.bit.CEVT1DIGFILTSEL = 0;
Sdfm2Regs.SDCOMP4CTL.bit.CEVT2DIGFILTSEL = 0;
Sdfm2Regs.SDIFLGCLR.bit.FLT4_FLG_CEVT1 = 1;
Sdfm2Regs.SDIFLGCLR.bit.FLT4_FLG_CEVT2 = 1;
Sdfm2Regs.SDCPARM4.bit.EN_CEVT1 = CEVT_interrupt_enable;
Sdfm2Regs.SDCPARM4.bit.EN_CEVT2 = CEVT_interrupt_enable;
Sdfm2Regs.SDFLT4CMPH1.bit.HLT = HightFlt;
Sdfm2Regs.SDFLT4CMPL1.bit.LLT = LowFLT;
break;
}
EDIS;
}
void sdfmGetResult(uint16_t N)
@ -315,7 +432,7 @@ void sdfmGetResult(uint16_t N)
FilterResult[N][loopCounter[N]] = *SdfmReadData[N];
sdfmAdc[N] = FilterResult[N][loopCounter[N]] - sdfmOffset[N];
if(N != SDFM_U_DC) {
if((N != SDFM_U_DC)&(N != SDFM_BRAKE)) {
if(loopCounter[N] < MAX_SAMPLES) loopCounter[N]++;
else
{

8
Projects/epwm_test_biss_c_cpu2/src/Peripherals/sdfm.h
View File

@ -60,12 +60,14 @@
#define FACTOR_VDC (SDFM_VOLTAGE_MAX/R_VDC*(R_DEL_VDC+R_VDC)/1000) //= 320/806*(2000000+806)/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_MOTOR_A (SDFM_VOLTAGE_MAX/R_DRW) //A //=320/4 = 80 A
#define FACTOR_CURRENT_BRAKE (FACTOR_CURRENT_BRAKE_A/BIT_MAX)
#define FACTOR_CURRENT_MOTOR (FACTOR_CURRENT_MOTOR_A/BIT_MAX)
#define FACTOR_CURRENT_MOTOR (FACTOR_CURRENT_MOTOR_A/BIT_MAX) // 80/32768 = 0.00244
#define DIV_FACTOR_CURRENT_MOTOR (1/FACTOR_CURRENT_MOTOR)
#define SDFM_FLT
void SdfmGpioInit(void);
void SdfmInitEnable(void);
void SdfmInitInterruptEn(void);
@ -74,7 +76,7 @@ void sdfm_start_conversion_current(void);
int16_t sdfm_get(int16_t N);
void SdfmTypeInit(void);
void sdfm_start_conversion_brake(void);
void sdfmInitPwmFlt(uint16_t N, uint16_t LowFLT, uint16_t HightFlt);
#endif /* SRC_SDFM_H_ */

1
Projects/epwm_test_biss_c_cpu2/src/init_perif.c
View File

@ -80,6 +80,7 @@ void InitPerif(void)
PWMAllInit();
PWMInitInterruptEn();
PWMTripInit();
SpiCInit();

5
Projects/epwm_test_biss_c_cpu2/src/vector.c
View File

@ -21,8 +21,7 @@
#include "temperature.h"
#include "rele.h"
#define IMAX_A 55.0 //A
#define IMAX (IMAX_A*BIT_MAX/FACTOR_CURRENT_MOTOR_A)
typedef struct {
int16_t Value16in; //
@ -113,7 +112,7 @@ void vectorControl(int16_t CurrentA, int16_t CurrentB, int16_t CurrentC, int16_t
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++; Mode = OffMode; CurFault++;}
if((Ia > IMAX_KZ)||(Ib>IMAX_KZ)||(Ic>IMAX_KZ)||(Ia<-IMAX_KZ)||(Ib<-IMAX_KZ)||(Ic<-IMAX_KZ) ) {OverCur[0] = Ia; OverCur[1] = Ib; OverCur[2] = Ic; ErrCur++; Mode = OffMode; CurFault++;}
UdcFiltered = Filter(sdfmUdc, &UdcFilter);

6
Projects/epwm_test_biss_c_cpu2/src/vector.h
View File

@ -37,9 +37,13 @@
#define VOLT_MAX_FACTOR VOLT_MAX_PROC/100.0
#define PI_REG_I_PROPOR 14.0 // 30
#define PI_REG_I_INTEGR 0.14 // 0.04
#define CURRENT_MAX 40.0 //A
#define CURRENT_MAX 45.0 //A
#define ZERO_LVL 0.00001f
#define IMAX_A_KZ 70.0 //A
#define IMAX_KZ (IMAX_A_KZ*BIT_MAX/FACTOR_CURRENT_MOTOR_A)
typedef struct
{
float q;

6
Projects/epwm_test_biss_c_cpu2/Описание проекта freemaster.txt
View File

@ -90,4 +90,10 @@ ___________________________________________
слева выбрать график I с биноклем который
после этого менять CurrLoop.piId.Kp и CurrLoop.piId.Ki чтобы изменить характеристику
___________________________________________
Измененние частоты ШИМ проводить при Mode = 0.
В других режимах частота меняться не будет.
Задаётся период в мкС от 50 до 125
В переменной PeriodPWM (слева выбрать вкладку timing)