TMS320F28335: 求助！！！！！283335进入非法中断

为什么我的程序可以正常烧录但是一运行就进入非法中断啊求各位大佬帮我看看原因

#include "DSP2833x_Device.h" // DSP2833x Headerfile Include File
#include "DSP2833x_Examples.h" // DSP2833x Examples Include File
#include "VSG.h" // DSP2833x Examples Include File
#include "VSG_CTrl.h"
#include <math.h> // 标准数学库，用于 sin() 函数
#include <stdio.h> // 用于输出
#include <time.h> // 用于获取系统时间 _iA_filterL
#include <COMM_485_FUN.h>
#include <uart.h>
#include <rs485.h>
#include <stdint.h>
#include <DSP2833x_Adc.h>
float t_Soft = 0,vcvv=0,time4=0,time2=0;
interrupt void time0(void) ;// 中断函数
interrupt void lower_priority_ISR() ;
void time1(void) ;
void pwm_generator(void);
#include "DSP2833x_Device.h" // DSP2833x Headerfile Include File
#include "DSP2833x_Examples.h" // DSP2833x Examples Include File
#include "DSP2833x_Adc.h"
float filtered_voltage=0;

typedef struct {
float x[2]; // 状态 [电压, 变化率]
float P[2][2]; // 协方差矩阵
float Q[2][2]; // 过程噪声协方差
float R; // 测量噪声协方差
float dt; // 采样间隔
} Kalman2D;
//Kalman2D kf;
Kalman2D kf[12];
void Kalman2D_Init(Kalman2D *kf, float initial_x, float initial_dx, float dt) {
kf->x[0] = initial_x;
kf->x[1] = initial_dx;
kf->P[0][0] = 1.0f; kf->P[0][1] = 0.0f;
kf->P[1][0] = 0.0f; kf->P[1][1] = 1.0f;
kf->Q[0][0] = 0.01f; kf->Q[0][1] = 0.0f;
kf->Q[1][0] = 0.0f; kf->Q[1][1] = 0.01f;
kf->R = 1.0f;
kf->dt = dt;
}

float Kalman2D_Update(Kalman2D *kf, float measurement) {
// 状态转移矩阵
float A[2][2] = {{1, kf->dt}, {0, 1}};
float H[2] = {1, 0}; // 测量矩阵

// 预测
float x_pred[2];
x_pred[0] = A[0][0] * kf->x[0] + A[0][1] * kf->x[1];
x_pred[1] = A[1][0] * kf->x[0] + A[1][1] * kf->x[1];

float P_pred[2][2];
P_pred[0][0] = A[0][0] * (kf->P[0][0] * A[0][0] + kf->P[0][1] * A[1][0]) +
A[0][1] * (kf->P[1][0] * A[0][0] + kf->P[1][1] * A[1][0]) + kf->Q[0][0];
// 类似计算其他元素...

// 更新
float innovation = measurement - (H[0] * x_pred[0] + H[1] * x_pred[1]);
float S = H[0] * (P_pred[0][0] * H[0] + P_pred[0][1] * H[1]) +
H[1] * (P_pred[1][0] * H[0] + P_pred[1][1] * H[1]) + kf->R;
float K[2];
K[0] = (P_pred[0][0] * H[0] + P_pred[0][1] * H[1]) / S;
K[1] = (P_pred[1][0] * H[0] + P_pred[1][1] * H[1]) / S;

kf->x[0] = x_pred[0] + K[0] * innovation;
kf->x[1] = x_pred[1] + K[1] * innovation;

// 更新协方差（简化）
kf->P[0][0] = (1 - K[0] * H[0]) * P_pred[0][0];
// 类似更新其他元素...

return kf->x[0];
}
#define ADC_usDELAY 5000L

Uint16 Sample_I = 0U;
float Real_I = 0.0f;
float Base_Current = 3.0f / 4096.0f;

void init_28335ADC_CLK(void)
{
EALLOW;
#define ADC_MODCLK 0x03
SysCtrlRegs.HISPCP.all = ADC_MODCLK;
EDIS;
}
// ADC初始化
void init_adc_config(void)
{
extern void DSP28x_usDelay(Uint32 Count);

EALLOW;
SysCtrlRegs.PCLKCR0.bit.ADCENCLK = 1;
ADC_cal();
EDIS;
AdcRegs.ADCTRL3.all = 0x00E0; // Power up bandgap/reference/ADC circuits
DELAY_US(ADC_usDELAY); // Delay before converting ADC channels

// Configure ADC
AdcRegs.ADCMAXCONV.all = 0x000F; // Setup 1 conv's on SEQ1 16个通道
AdcRegs.ADCTRL1.bit.ACQ_PS = 0x1;

AdcRegs.ADCTRL3.bit.SMODE_SEL = 0; // 顺序采样
AdcRegs.ADCTRL1.bit.CPS = 0; // 对外设时钟HSPCLK不分频
AdcRegs.ADCTRL3.bit.ADCCLKPS = 0x0; // ADC内核时钟不分频 ADCCLK = HSPCLK / (CPS + 1) = 25MHz
AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 级联排序模式
AdcRegs.ADCTRL1.bit.CONT_RUN = 1; // 连续模式
AdcRegs.ADCTRL1.bit.SEQ_OVRD = 1; // 排序覆盖

// 转换顺序
AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x00U; // Setup ADCINA0 as 1st SEQ1 conv.
AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x01U;
AdcRegs.ADCCHSELSEQ1.bit.CONV02 = 0x02U;
AdcRegs.ADCCHSELSEQ1.bit.CONV03 = 0x03U;

AdcRegs.ADCCHSELSEQ2.bit.CONV04 = 0x04U;
AdcRegs.ADCCHSELSEQ2.bit.CONV05 = 0x05U;
AdcRegs.ADCCHSELSEQ2.bit.CONV06 = 0x06U;
AdcRegs.ADCCHSELSEQ2.bit.CONV07 = 0x07U;

AdcRegs.ADCCHSELSEQ3.bit.CONV08 = 0x08U;
AdcRegs.ADCCHSELSEQ3.bit.CONV09 = 0x09U;
AdcRegs.ADCCHSELSEQ3.bit.CONV10 = 0x0AU;
AdcRegs.ADCCHSELSEQ3.bit.CONV11 = 0x0BU;

AdcRegs.ADCCHSELSEQ4.bit.CONV12 = 0x0CU;
AdcRegs.ADCCHSELSEQ4.bit.CONV13 = 0x0DU;
AdcRegs.ADCCHSELSEQ4.bit.CONV14 = 0x0EU;
AdcRegs.ADCCHSELSEQ4.bit.CONV15 = 0x0FU;

AdcRegs.ADCTRL2.bit.EPWM_SOCA_SEQ1 = 1;// Enable SOCA from ePWM to start SEQ1
AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 1; // Enable SEQ1 interrupt (every EOS)

// Assumes ePWM1 clock is already enabled in InitSysCtrl();
EPwm1Regs.ETSEL.bit.SOCAEN = 1; // Enable SOC on A group
EPwm1Regs.ETSEL.bit.SOCASEL = 4; // Select SOC from from CPMA on upcount CTR = CMPA且为向上计数是产生触发事件
EPwm1Regs.ETPS.bit.SOCAPRD = 1; // Generate pulse on 1st event 在第一个事件时产生SOCA信号
EPwm1Regs.CMPA.half.CMPA = 0x0080; // Set compare A value

// 设置EPWM触发源
/* EPwm1Regs.TBPRD = 0x1D4C/10; // Set period for ePWM1 7500 10K
EPwm1Regs.TBCTR = 0x0000U; //
EPwm1Regs.TBCTL.bit.CTRMODE = 2; // up-down模式
EPwm1Regs.TBCTL.bit.HSPCLKDIV = 0x00; // 使用系统时钟
EPwm1Regs.TBCTL.bit.CLKDIV = 0x00;*/
}
// 转换计算

/*void adc_isr(void)
{
Sample_I = AdcRegs.ADCRESULT0 >>4; // 采样数据
Real_I = (float)Sample_I * Base_Current;// 实际电流
}*/
// 定义16个通道的原始采样值和转换结果
volatile Uint16 Sample[16] = {0}; // 原始ADC值数组
volatile float Real[16] = {0.0f}; // 转换后的实际值数组
const float Base_Voltage = 3.0 / 4096.0f; // 基准电压系数
int i=0;
volatile int button_state = 0; // 状态标志：0-功能A，1-功能B
volatile float last_press_time = 0;
volatile float uwTick = 0; // 需在中断中自增
#define HAL_GetTick() (uwTick)
void CheckButton(void) {
if (GpioDataRegs.GPBDAT.bit.GPIO61 == 0) { // 低电平触发
if ((HAL_GetTick() - last_press_time) > 500) { // 50ms消抖
button_state ^= 1;
last_press_time = HAL_GetTick();
}
}
}
void adc_isr(void)
{
// 读取所有通道结果（网页1、网页3）
Sample[0] = AdcRegs.ADCRESULT0 >>4; // ADCINA0
Sample[1] = AdcRegs.ADCRESULT1 >>4; // ADCINA1
Sample[2] = AdcRegs.ADCRESULT2 >>4; // ADCINA2
Sample[3] = AdcRegs.ADCRESULT3 >>4; // ADCINA3
Sample[4] = AdcRegs.ADCRESULT4 >>4; // ADCINA4
Sample[5] = AdcRegs.ADCRESULT5 >>4; // ADCINA5
Sample[6] = AdcRegs.ADCRESULT6 >>4; // ADCINA6
Sample[7] = AdcRegs.ADCRESULT7 >>4; // ADCINA7
Sample[8] = AdcRegs.ADCRESULT8 >>4; // ADCINB0
Sample[9] = AdcRegs.ADCRESULT9 >>4; // ADCINB1
Sample[10] = AdcRegs.ADCRESULT10 >>4; // ADCINB2
Sample[11] = AdcRegs.ADCRESULT11 >>4; // ADCINB3
Sample[12] = AdcRegs.ADCRESULT12 >>4; // ADCINB4
Sample[13] = AdcRegs.ADCRESULT13 >>4; // ADCINB5
Sample[14] = AdcRegs.ADCRESULT14 >>4; // ADCINB6
Sample[15] = AdcRegs.ADCRESULT15 >>4; // ADCINB7

// 批量转换实际值（网页1、网页3）
for(i=0; i<16; i++){
Real[i] = (float)Sample[i] * Base_Voltage;
}

AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1; // 清除中断标志（网页3）
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; // 响应中断Delay
}
int stude =0;
float data_values[12]; // 声明一个包含12个浮点数的数组
void lower_priority_ISR1() ;
void main() {
InitSysCtrl(); // 初始化系统控制器
InitGpio(); // 初始化 GPIO

RS485_Init(115200);
InitEPwmGpio();
ePWMSetup();
EPWM1_2_3_4_5_6_enable();
// EPWM1_2_3_4_5_6_disable();
/* EPwm4Regs.TZFRC.bit.OST = 1;
EPwm5Regs.TZFRC.bit.OST = 1;
EPwm6Regs.TZFRC.bit.OST = 1;*/
/*extern Uint16 RamfuncsLoadStart;
extern Uint16 RamfuncsLoadEnd;
extern Uint16 RamfuncsRunStart;
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (Uint32)&RamfuncsLoadEnd - (Uint32)&RamfuncsLoadStart);
//*/
InitPieCtrl(); // 初始化 PIE 控制器 PIE（Peripheral Interrupt Expansion）
IER = 0x0000; // 禁用所有中断
IFR = 0x0000; // 清除所有中断标志
InitPieVectTable(); // 初始化 PIE 向量表
DINT; // 禁用全局中断

EALLOW;
PieVectTable.TINT0 = &time0; // 中断优先级由 CPU 中断编号（INTx） 决定，编号越小，优先级越高。
PieVectTable.TINT2 = &lower_priority_ISR; // Timer1 ISR (低优先级)
EDIS;

IER |= M_INT1; // 使能 CPU 级别的 INT1 中断 (TIM0 在 INT1 组中)
IER |= M_INT14; // 使能 CPU 级别的 INT14 中断（CpuTimer2，直接）
PieCtrlRegs.PIEIER1.bit.INTx7 = 1; // 使能 PIE 组1 的第7个中断（TIM0 中断）
// PieCtrlRegs.PIEIER3.bit.INTx1 = 1; // 将 Timer0 中断移到 PIE 组 3 第 1 个通道

ledinit();
LED_Control(LED1_PIN, LED_OFF);
LED_ControlA(LED2_PIN, LED_OFF);
LED_ControlA(LED3_PIN, LED_OFF);
EALLOW;
GpioCtrlRegs.GPBMUX2.bit.GPIO61 = 0; // 设为GPIO功能[6,7](@ref)
GpioCtrlRegs.GPBPUD.bit.GPIO61 = 0; // 启用上拉电阻[5](@ref)
GpioCtrlRegs.GPBDIR.bit.GPIO61 = 0; // 输入模式[1,6](@ref)
EDIS;

EINT;使能全局中断
ERTM;使能实时中断
init_28335ADC_CLK（）;
init_adc_config（）;
int i = 0;
// 初始化每个滤波器
for （ i = 0;i < 12;i++） {
Kalman2D_Init（&kf[i]， 0， 0， 1e-4）; // 初始状态均为0
}
InitCpuTimers（）;
Sci_AB1_Gpio_initial（） ;
Sci_A_Gpio_initial（） ;SCI_A_B_GPIO
SciA1_485_initial（） ;
*/
SciB1_485_initial（）;//485

ConfigCpuTimer(&CpuTimer0, 150, 10); // 配置定时器0
ConfigCpuTimer(&CpuTimer2, 150, 1000); // 配置定时器2
StartCpuTimer0();
StartCpuTimer2();

while (1) {
if (time2) {
if (t_Soft > 2e2) {
t_Soft = 0;
LED_Control(LED1_PIN, LED_TOGGLE);
/* LED_ControlA(LED2_PIN, LED_TOGGLE);
LED_ControlA(LED3_PIN, LED_TOGGLE);*/
vcvv++;
}
t_Soft++;
time2 = 0; time1();
/*if(!LOADTicker2)
{ EPWM1_2_3_4_5_6_enable();
time1();

}*/

}

if （time4） {
time4 = 0;
lower_priority_ISR1（）;
}

}
}

interrupt void time0（void） { // 中断函数
time2 = 1;
// 中断固定处理部分
PieCtrlRegs.PIEACK.all |= PIEACK_GROUP1;
CpuTimer0Regs.TCR.bit.TIF = 1;写1清除中断标志（该位为1表明进入中断，该位为0表明中断函数结束）
CpuTimer0Regs.TCR.bit.TRB = 1;// 重置计数器
}

中断 void lower_priority_ISR（） {
time4 = 1;
//
}

void lower_priority_ISR1() {
// if (t_Soft > 2)
{
/* t_Soft = 0;
vcvv++;*/
// SCIB1_SendFormattedData( Real[0]+1, filtered_voltage , filtered_voltage+1 );

填充数据
//Kalman2D kf[12];

data_values[0] =Kalman2D_Update（&kf[0]， Real[0]）;
data_values[1] = Kalman2D_Update（&kf[1]， Real[1]）;
/// data_values[1] = 实数[0];
data_values[2] = Kalman2D_Update（&kf[2]， Real[2]）;
data_values[3] = Kalman2D_Update（&kf[3]， Real[3]）;
data_values[4] = Kalman2D_Update（&kf[4]， Real[4]）;
data_values[5] = Kalman2D_Update（&kf[5]， Real[5]）;
data_values[6] = Kalman2D_Update（&kf[6]， Real[6]）;
data_values[7] = Kalman2D_Update（&kf[7]， Real[7]）;
data_values[8] = Kalman2D_Update（&kf[8]， Real[8]）;
data_values[9] = Kalman2D_Update（&kf[9]， Real[9]）;
data_values[10] = Kalman2D_Update（&kf[10]， Real[10]）;
data_values[11] = Kalman2D_Update（&kf[11]， Real[11]）;
/*
data_values[1] = 实数[1];
data_values[2] = 实数[2];
data_values[3] = 实数[3];
data_values[4] = 实数[4];
data_values[5] = 实数[5];
data_values[6] = 实数[6];
data_values[7] = 实数[7];
data_values[8] = 实数[8];
data_values[9] = 实数[9];
data_values[10] =真实[10];
data_values[11] = Real[11];*/
// 调用优化后的函数
// SCIB1_SendFormattedData_12（0， Real）;
SCIB1_SendFormattedData1（0， Real， 16）;
SCIB1_SendFormattedData1（0， data_values， 12）;
//SCIA_SendFormattedData1（0， data_values， 12）;
//SCIA_SendFormattedData1（long sample_index， float values[]， int value_count）;

CheckButton();
if (!button_state) {
SCIA_SendFormattedData1(0, data_values, 12); // 功能A
stude =0;
} else {
SCIA_SendFormattedData1(1, Real, 16); // 功能B
stude =1;
}
}

}

void time1(void) { // 中断函数

adc_isr();
pwm_generator();
uwTick++;
// CpuTimer0.InterruptCount = (CpuTimer0.InterruptCount >= 10000)? 0 : CpuTimer0.InterruptCount + 1;
}

void pwm_generator(void)
{
// ua 是您的调制信号，应在 0 到 1 范围内
// 设置 EPWM1A
/*EPwm1Regs.CMPA.half.CMPA = (1 + ua1) * (EPwm1Regs.TBPRD * 0.5);
EPwm2Regs.CMPA.half.CMPA = (1 + ub1) * (EPwm1Regs.TBPRD * 0.5);
EPwm3Regs.CMPA.half.CMPA = (1 + uc1) * (EPwm1Regs.TBPRD * 0.5);*/
// EPwm1Regs.CMPA.half.CMPA=((float)EPwm1Regs.TBPRD*0.5);
EPwm1Regs.CMPA.half.CMPA=0.6*((float)EPwm1Regs.TBPRD);
EPwm1Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm1Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR;
EPwm1Regs.CMPB = 0.6* (float)EPwm1Regs.TBPRD; // CMPB直接赋值
EPwm1Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm1Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm1Regs.AQCTLB.bit.CBD = AQ_CLEAR;
//EPwm1Regs.AQCTLA.bit.PRD = AQ_NO_ACTION;
EPwm2Regs.CMPA.half.CMPA=0.1*((float)EPwm2Regs.TBPRD);
EPwm2Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm2Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm2Regs.AQCTLA.bit.CAD = AQ_CLEAR;
////////////////CBU与CBD独立控制同时需要禁止死区相关模块/////////
EPwm2Regs.CMPB = 0.2 * (float)EPwm2Regs.TBPRD; // CMPB直接赋值
EPwm2Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm2Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm2Regs.AQCTLB.bit.CBD = AQ_CLEAR;

EPwm3Regs.CMPA.half.CMPA=0.1*((float)EPwm3Regs.TBPRD);
EPwm3Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm3Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm3Regs.AQCTLA.bit.CAD = AQ_CLEAR;
////////////////CBU与CBD独立控制同时需要禁止死区相关模块/////////
EPwm3Regs.CMPB = 0.2 * (float)EPwm3Regs.TBPRD; // CMPB直接赋值
EPwm3Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm3Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm3Regs.AQCTLB.bit.CBD = AQ_CLEAR;

EPwm4Regs.CMPA.half.CMPA=0.1*((float)EPwm4Regs.TBPRD);
EPwm4Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm4Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm4Regs.AQCTLA.bit.CAD = AQ_CLEAR;
////////////////CBU与CBD独立控制同时需要禁止死区相关模块/////////
EPwm4Regs.CMPB = 0.2 * (float)EPwm4Regs.TBPRD; // CMPB直接赋值
EPwm4Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm4Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm4Regs.AQCTLB.bit.CBD = AQ_CLEAR;

EPwm5Regs.CMPA.half.CMPA=0.1*((float)EPwm5Regs.TBPRD);
EPwm5Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm5Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm5Regs.AQCTLA.bit.CAD = AQ_CLEAR;
////////////////CBU与CBD独立控制同时需要禁止死区相关模块/////////
EPwm5Regs.CMPB = 0.2 * (float)EPwm5Regs.TBPRD; // CMPB直接赋值
EPwm5Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm5Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm5Regs.AQCTLB.bit.CBD = AQ_CLEAR;

EPwm6Regs.CMPA.half.CMPA=0.99*（（浮动）EPwm6Regs.TBPRD）;
EPwm6Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm6Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm6Regs.AQCTLA.bit.CAD = AQ_CLEAR;
////////////////CBU与CBD独立控制同时需要禁止死区相关模块/////////
EPwm6Regs.CMPB = 0.99* （float）EPwm6Regs.TBPRD;CMPB直接赋值
EPwm6Regs.AQCTLB.bit.ZRO = AQ_CLEAR;
EPwm6Regs.AQCTLB.bit.CBU = AQ_SET;
EPwm6Regs.AQCTLB.bit.CBD = AQ_CLEAR;

/*
EPwm2Regs.CMPA.half.CMPA=（（浮动）EPwm2Regs.TBPRD*0.5）;
EPwm2Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm2Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm2Regs.AQCTLA.bit.CAD = AQ_CLEAR;
//EPwm2Regs.AQCTLA.bit.PRD = AQ_NO_ACTION;

/*
EPwm3Regs.CMPA.half.CMPA=（1+uc）*（（浮动）EPwm3Regs.TBPRD*0.5）;
/*EPwm3Regs.AQCTLA.bit.ZRO = AQ_SET;
EPwm3Regs.AQCTLA.bit.CAU = AQ_CLEAR;
EPwm3Regs.AQCTLA.bit.CAD = AQ_SET;*/
/* EPwm3Regs.AQCTLA.bit.ZRO = AQ_CLEAR;
EPwm3Regs.AQCTLA.bit.CAU = AQ_SET;
EPwm3Regs.AQCTLA.bit.CAD = AQ_CLEAR;
//EPwm3Regs.AQCTLA.bit.PRD = AQ_NO_ACTION;*/

}

/*
//###########################################################################
//
文件：F28335.cmd

标题：F28335 设备

的链接器命令文件 ###########################################################################
$TI版本：F2833x/f2823x 头文件和外设示例 v142 $
$Release日期：2016 年 11 月 1 日 $
$Copyright：版权所有 （c） 2007-2016 德州仪器公司 -
http://www.ti.com/ 保留所有权利 $
//###########################################################################
*/

/* ======================================================
对于 Code Composer Studio V2.2 及更高版本
---------------------------------------
除了此内存链接器命令文件外，还可以
将标头链接器命令文件直接添加到项目中。
需要 header linker 命令文件才能将
外设结构链接到内存映射中的
适当位置。

头文件链接器文件位于 <base>\DSP2833x_Headers\cmd

对于 BIOS 应用程序，请添加：DSP2833x_Headers_BIOS.cmd
对于非 BIOS 应用程序，请添加：DSP2833x_Headers_nonBIOS.cmd
========================================================= */

/* ======================================================
对于 V2.2 之前的 Code Composer Studio，
--------------------------------------
1） 使用以下 -l 语句之一在项目中包含
标头链接器命令文件。需要头链接器
文件将外围结构链接到内存映射中的适当
位置 */

/* Uncomment this line to include file only for non-BIOS applications */
/* -l DSP2833x_Headers_nonBIOS.cmd */

/* Uncomment this line to include file only for BIOS applications */
/* -l DSP2833x_Headers_BIOS.cmd */

/* 2） 在您的项目中，将 <base>\DSP2833x_headers\cmd 的路径添加到
库搜索路径中，位于 project->build 选项、链接器选项卡、
库搜索路径 （-i） 下。
/*========================================================= */

/* Define the memory block start/length for the F28335
PAGE 0 will be used to organize program sections
PAGE 1 will be used to organize data sections

注意：
F28335 上的内存块在 PAGE 0 和 PAGE 1 中是一致的（即相同的
物理内存）。
也就是说，不应为 PAGE 0 和 PAGE 1
定义相同的内存区域。
这样做将导致程序
和/或数据损坏。

L0/L1/L2 和 L3 内存块是镜像的 - 也就是说
，它们可以在高内存或低内存下访问。
为简单起见，此
链接器文件中只使用一个实例。

如果需要，可以组合
连续的 SARAM 内存块以创建更大的内存块。
*/

MEMORY
{
PAGE 0： /* 程序内存 */
/* 内存 （RAM/FLASH/OTP） 块可以移动到 PAGE1 进行数据分配 */

ZONE0 : origin = 0x004000, length = 0x001000 /* XINTF zone 0 */
RAML0 : origin = 0x008000, length = 0x004000 /* on-chip RAM block L0 */
// RAML1 : origin = 0x009000, length = 0x001000 /* on-chip RAM block L1 */
// RAML2 : origin = 0x00A000, length = 0x001000 /* on-chip RAM block L2 */
//RAML3 : origin = 0x00B000, length = 0x001000 /* on-chip RAM block L3 */
ZONE6 : origin = 0x0100000, length = 0x100000 /* XINTF zone 6 */
ZONE7A : origin = 0x0200000, length = 0x00FC00 /* XINTF zone 7 - program space */
FLASHH : origin = 0x300000, length = 0x008000 /* on-chip FLASH */
FLASHG : origin = 0x308000, length = 0x008000 /* on-chip FLASH */
FLASHF : origin = 0x310000, length = 0x008000 /* on-chip FLASH */
FLASHE : origin = 0x318000, length = 0x008000 /* on-chip FLASH */
FLASHD : origin = 0x320000, length = 0x008000 /* on-chip FLASH */
FLASHC : origin = 0x328000, length = 0x008000 /* on-chip FLASH */
FLASHA : origin = 0x338000, length = 0x007F80 /* on-chip FLASH */
CSM_RSVD : origin = 0x33FF80, length = 0x000076 /* Part of FLASHA. Program with all 0x0000 when CSM is in use. */
BEGIN : origin = 0x33FFF6, length = 0x000002 /* Part of FLASHA. Used for "boot to Flash" bootloader mode. */
CSM_PWL : origin = 0x33FFF8, length = 0x000008 /* Part of FLASHA. CSM password locations in FLASHA */
OTP : origin = 0x380400, length = 0x000400 /* on-chip OTP */
ADC_CAL : origin = 0x380080, length = 0x000009 /* ADC_cal function in Reserved memory */

IQTABLES : origin = 0x3FE000, length = 0x000b50 /* IQ Math Tables in Boot ROM */
IQTABLES2 : origin = 0x3FEB50, length = 0x00008c /* IQ Math Tables in Boot ROM */
FPUTABLES : origin = 0x3FEBDC, length = 0x0006A0 /* FPU Tables in Boot ROM */
ROM : origin = 0x3FF27C, length = 0x000D44 /* Boot ROM */
RESET : origin = 0x3FFFC0, length = 0x000002 /* part of boot ROM */
VECTORS : origin = 0x3FFFC2, length = 0x00003E /* part of boot ROM */

PAGE 1 : /* Data Memory */
/* Memory (RAM/FLASH/OTP) blocks can be moved to PAGE0 for program allocation */
/* Registers remain on PAGE1 */

BOOT_RSVD : origin = 0x000000, length = 0x000050 /* Part of M0, BOOT rom will use this for stack */
RAMM0 : origin = 0x000050, length = 0x0003B0 /* on-chip RAM block M0 */
RAMM1 : origin = 0x000400, length = 0x000400 /* on-chip RAM block M1 */
RAML4 : origin = 0x00C000, length = 0x002000 /* on-chip RAM block L1 */
// RAML5 : origin = 0x00D000, length = 0x001000 /* on-chip RAM block L1 */
RAML6 : origin = 0x00E000, length = 0x001000 /* on-chip RAM block L1 */
RAML7 : origin = 0x00F000, length = 0x001000 /* on-chip RAM block L1 */
ZONE7B : origin = 0x20FC00, length = 0x000400 /* XINTF zone 7 - data space */
FLASHB : origin = 0x330000, length = 0x008000 /* on-chip FLASH */
}

/* Allocate sections to memory blocks.
Note:
codestart user defined section in DSP28_CodeStartBranch.asm used to redirect code
execution when booting to flash
ramfuncs user defined section to store functions that will be copied from Flash into RAM
*/

SECTIONS
{

/* Allocate program areas: */
.cinit : > FLASHA PAGE = 0
.pinit : > FLASHA, PAGE = 0
.text : > FLASHA PAGE = 0
codestart : > BEGIN PAGE = 0
ramfuncs : LOAD = FLASHD,
RUN = RAML0,
LOAD_START(_RamfuncsLoadStart),
LOAD_END(_RamfuncsLoadEnd),
RUN_START(_RamfuncsRunStart),
LOAD_SIZE(_RamfuncsLoadSize),
PAGE = 0

csmpasswds : > CSM_PWL PAGE = 0
csm_rsvd : > CSM_RSVD PAGE = 0

/* Allocate uninitalized data sections: */
.stack : > RAML7 PAGE = 1
.ebss : > RAML4 PAGE = 1
.esysmem : > RAMM1 PAGE = 1

/* Initalized sections go in Flash */
/* For SDFlash to program these, they must be allocated to page 0 */
.econst : > RAML0 PAGE = 0
.switch : >RAML0 PAGE = 0

/* Allocate IQ math areas: */
IQmath : > FLASHC PAGE = 0 /* Math Code */
IQmathTables : > IQTABLES, PAGE = 0, TYPE = NOLOAD

/* Uncomment the section below if calling the IQNexp() or IQexp()
functions from the IQMath.lib library in order to utilize the
relevant IQ Math table in Boot ROM (This saves space and Boot ROM
is 1 wait-state). If this section is not uncommented, IQmathTables2
will be loaded into other memory (SARAM, Flash, etc.) and will take
up space, but 0 wait-state is possible.
*/
/*
IQmathTables2 : > IQTABLES2, PAGE = 0, TYPE = NOLOAD
{

IQmath.lib<IQNexpTable.obj> (IQmathTablesRam)

}
*/

FPUmathTables : > FPUTABLES, PAGE = 0, TYPE = NOLOAD

/* Allocate DMA-accessible RAM sections: */
DMARAML4 : > RAML4, PAGE = 1
DMARAML5 : > RAML4, PAGE = 1
DMARAML6 : > RAML6, PAGE = 1
DMARAML7 : > RAML7, PAGE = 1

/* Allocate 0x400 of XINTF Zone 7 to storing data */
ZONE7DATA : > ZONE7B, PAGE = 1

/* .reset is a standard section used by the compiler. It contains the */
/* the address of the start of _c_int00 for C Code. /*
/* When using the boot ROM this section and the CPU vector */
/* table is not needed. Thus the default type is set here to */
/* DSECT */
.reset : > RESET, PAGE = 0, TYPE = DSECT
vectors : > VECTORS PAGE = 0, TYPE = DSECT

/* Allocate ADC_cal function (pre-programmed by factory into TI reserved memory) */
.adc_cal : load = ADC_CAL, PAGE = 0, TYPE = NOLOAD

}

/*
//===========================================================================
文件结束。
//===========================================================================