2837xD之CPU2使用外设

最新推荐文章于 2023-12-08 14:58:26 发布
最新推荐文章于 2023-12-08 14:58:26 发布
阅读量2.2k 收藏 13
点赞数 3
分类专栏： 2837x 文章标签： dsp 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42151264/article/details/106960160
版权

2837xD之CPU2使用外设

一、文章目的

上一篇文章主要是解决了2837xD之间的IPC交互问题，但是需要的目标是CPU2调用串口等通信功能进行信息发送到上位机的交互。因此本文主要是学习利用CPU2来驱动外设的主要流程。

1.主要准备

因为手上没有2837xD的开发板，本次实验还是以学习例程为主（有点难受）。。。

二、代码阅读

代码目的：CPU1进行时钟初始化与GPIO初始化，CPU2进行驱动外设（ADC与EPWM）
　　　 其中，EPWM1工作在up-mode，GPIO0（EPWM1A）、GPIO1(EPWM1B)输出。
　　　 ADC工作在连续采样模式，可以将GPIO0接入ADCINA0读取输出结果。

1.CUP1代码

void main(void)
{
   InitSysCtrl();//初始化系统时钟等
   
   InitGpio();//初始化GPIO（解锁所有GPIO等）
   
   DINT;//禁止中断
   InitPieCtrl();//恢复PIE控制器默认状态
   IER = 0x0000;
   IFR = 0x0000; //禁止中断与清除所有中断标志位
   InitPieVectTable();//初始化中断向量表
   EINT;  // 使能全局中断
   ERTM;  // 使能实时中断
   
   InitEPwm1Gpio(); //初始化EPWM1GPIO(只有CPU1能够进行GPIO中的MUX配置)
   
   EALLOW;
   DevCfgRegs.CPUSEL0.bit.EPWM1 = 1;//将外设控制权给CPU2
   DevCfgRegs.CPUSEL11.bit.ADC_A = 1;//将控制权给CPU2
   EDIS;	
   
   while(1)
   {
    	asm(" nop");
   }
}

下面先附上==InitEPwm1Gpio()==函数中的代码：

void InitEPwm1Gpio(void)
{
	EALLOW;
    GpioCtrlRegs.GPAPUD.bit.GPIO0 = 1;    
    GpioCtrlRegs.GPAPUD.bit.GPIO1 = 1;  //设置GPIO0与GPIO1为上拉模式

	GpioCtrlRegs.GPAMUX1.bit.GPIO0 = 1;   
    GpioCtrlRegs.GPAMUX1.bit.GPIO1 = 1;   // 设置GPIO0与GPIO1工作在EPWM模式
    EDIS;
}

通过上面的函数可以看出，需要注意的有以下几点：

  • 本例中CPU1负责整个系统的初始化操作，GPIO的MUX设置只能在CPU1中完成。
  • 需要在CPU1为CPU2分配相应的外设。
  • 要提一下的是CPUSEL0-CPUSEL14寄存器决定了每个外设是属于CPU1 or CPU2

CPU1中内容不多，下面康康CPU2中的内容！

CPU2中的代码

   void main（void）
   {
     InitSysCtrl(); //初始化系统时钟（与CPU1中的函数的内容一模一样）
     
     DINT;//关中断
     InitPieCtrl(); //初始化PIE控制器（与CPU1中的函数的内容一模一样）
     IER = 0x0000;
     IFR = 0x0000;  //禁止中断与清除中断标志
     InitPieVectTable();//初始化中断向量表
     
	 EALLOW;
	 PieVectTable.EPWM1_INT = &epwm1_isr;  //指定EPWM1的中断函数
	 EDIS;
	
	 EALLOW;
	 CpuSysRegs.PCLKCR2.bit.EPWM1=1;
	 CpuSysRegs.PCLKCR13.bit.ADC_A = 1;
	 EDIS;                                //开启相关外设对应的时钟

以上部分都是对工作背景以及外设的准备工作。

/接着上部分代码/
	ConfigureADC(); //ADC设置函数[ADC工作在12位，单端采用模式，转换结束后产生中断，采样频率4分频]
	SetupADCContinuous(0); //设置ADC

下面附上==SetupADCContinuous(0)==函数中的代码：

void SetupADCContinuous(Uint16 channel)
{
	Uint16 acqps;

	//determine minimum acquisition window (in SYSCLKS) based on resolution
	if(ADC_RESOLUTION_12BIT == AdcaRegs.ADCCTL2.bit.RESOLUTION){
		acqps = 14; //75ns
	}
	else { //resolution is 16-bit
		acqps = 63; //320ns
	}

	EALLOW;
	AdcaRegs.ADCSOC0CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC1CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC2CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC3CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC4CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC5CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC6CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC7CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC8CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC9CTL.bit.CHSEL  = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC10CTL.bit.CHSEL = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC11CTL.bit.CHSEL = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC12CTL.bit.CHSEL = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC13CTL.bit.CHSEL = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC14CTL.bit.CHSEL = channel;  //SOC will convert on channel
	AdcaRegs.ADCSOC15CTL.bit.CHSEL = channel;  //SOC will convert on channel

	AdcaRegs.ADCSOC0CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC1CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC2CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC3CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC4CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC5CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC6CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC7CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC9CTL.bit.ACQPS  = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC10CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC11CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC12CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC13CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC14CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles
	AdcaRegs.ADCSOC15CTL.bit.ACQPS = acqps;    //sample window is acqps + 1 SYSCLK cycles

	AdcaRegs.ADCINTSEL1N2.bit.INT1E = 0; //disable INT1 flag
	AdcaRegs.ADCINTSEL1N2.bit.INT2E = 0; //disable INT2 flag
	AdcaRegs.ADCINTSEL3N4.bit.INT3E = 0; //disable INT3 flag
	AdcaRegs.ADCINTSEL3N4.bit.INT4E = 0; //disable INT4 flag

	AdcaRegs.ADCINTSEL1N2.bit.INT1CONT = 0;
	AdcaRegs.ADCINTSEL1N2.bit.INT2CONT = 0;
	AdcaRegs.ADCINTSEL3N4.bit.INT3CONT = 0;
	AdcaRegs.ADCINTSEL3N4.bit.INT4CONT = 0;

	AdcaRegs.ADCINTSEL1N2.bit.INT1SEL = 6;  //end of SOC6 will set INT1 flag
	AdcaRegs.ADCINTSEL1N2.bit.INT2SEL = 14; //end of SOC14 will set INT2 flag
	AdcaRegs.ADCINTSEL3N4.bit.INT3SEL = 7;  //end of SOC7 will set INT3 flag
	AdcaRegs.ADCINTSEL3N4.bit.INT4SEL = 15; //end of SOC15 will set INT4 flag

	//ADCINT2 will trigger first 8 SOCs
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC0 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC1 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC2 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC3 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC4 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC5 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC6 = 2;
   	AdcaRegs.ADCINTSOCSEL1.bit.SOC7 = 2;

	//ADCINT1 will trigger second 8 SOCs
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC8 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC9 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC10 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC11 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC12 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC13 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC14 = 1;
   	AdcaRegs.ADCINTSOCSEL2.bit.SOC15 = 1;
}

上述的设置完成了SOC0-SOC15都采集某一个通道，并且：
SOC0-SOC7由ADCINT2可以触发
SOC8-SOC15由ADCINT1可以触发

SOC6完成后触发ADCINT1中断
SOC14完成后触发ADCINT2中断
SOC7完成后触发ADCINT3中断
SOC15完成后触发ADCINT4中断

/接上述程序/
	EALLOW;
	CpuSysRegs.PCLKCR0.bit.TBCLKSYNC =0;//停止记述
	EDIS;
	InitEPwm1Example();
	EALLOW;
	CpuSysRegs.PCLKCR0.bit.TBCLKSYNC =1;//开始记述
	EDIS;

下面附上==InitEPwm1Example()==函数中的代码：

void InitEPwm1Example()
{
   // Setup TBCLK
   EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP; // Count up
   EPwm1Regs.TBPRD = EPWM1_TIMER_TBPRD;       // Set timer period
   EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE;    // Disable phase loading
   EPwm1Regs.TBPHS.bit.TBPHS = 0x0000;        // Phase is 0
   EPwm1Regs.TBCTR = 0x0000;                  // Clear counter
   EPwm1Regs.TBCTL.bit.HSPCLKDIV = TB_DIV2;   // Clock ratio to SYSCLKOUT
   EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV2;

   // Setup shadow register load on ZERO
   EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;
   EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;
   EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;
   EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;

   // Set Compare values
   EPwm1Regs.CMPA.bit.CMPA = EPWM1_MIN_CMPA;     // Set compare A value
   EPwm1Regs.CMPB.bit.CMPB = EPWM1_MIN_CMPB;     // Set Compare B value

   // Set actions
   EPwm1Regs.AQCTLA.bit.ZRO = AQ_SET;            // Set PWM1A on Zero
   EPwm1Regs.AQCTLA.bit.CAU = AQ_CLEAR;          // Clear PWM1A on event A, up count

   EPwm1Regs.AQCTLB.bit.ZRO = AQ_SET;            // Set PWM1B on Zero
   EPwm1Regs.AQCTLB.bit.CBU = AQ_CLEAR;          // Clear PWM1B on event B, up count

   // Interrupt where we will change the Compare Values
   EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO;     // Select INT on Zero event
   EPwm1Regs.ETSEL.bit.INTEN = 1;                // Enable INT
   EPwm1Regs.ETPS.bit.INTPRD = ET_3RD;           // Generate INT on 3rd event

   // Information this example uses to keep track
   // of the direction the CMPA/CMPB values are
   // moving, the min and max allowed values and
   // a pointer to the correct ePWM registers
   epwm1_info.EPwm_CMPA_Direction = EPWM_CMP_UP; // Start by increasing CMPA & CMPB
   epwm1_info.EPwm_CMPB_Direction = EPWM_CMP_UP;
   epwm1_info.EPwmTimerIntCount = 0;             // Zero the interrupt counter
   epwm1_info.EPwmRegHandle = &EPwm1Regs;        // Set the pointer to the ePWM module
   epwm1_info.EPwmMaxCMPA = EPWM1_MAX_CMPA;      // Setup min/max CMPA/CMPB values
   epwm1_info.EPwmMinCMPA = EPWM1_MIN_CMPA;
   epwm1_info.EPwmMaxCMPB = EPWM1_MAX_CMPB;
   epwm1_info.EPwmMinCMPB = EPWM1_MIN_CMPB;

}

上述的设置完成了EPWM1的设置：

  • 1.PRD=4096 ，时钟两分频，禁止同步信号（工作在up mode）
  • 2.CMPA与CMPB ，在50-4050之间循环（主函数实现，这里看不到）
  • 3.CTR=0时，触发中断（每三次产生一次中断）
	/接上述主程序/
	
	IER |= M_INT3;
	PieCtrlRegs.PIEIER3.bit.INTx1 = 1;

 
    EINT;  // Enable Global interrupt INTM
    ERTM;  // Enable Global realtime interrupt DBGM

	for(resultsIndex = 0; resultsIndex < RESULTS_BUFFER_SIZE; resultsIndex++)
    {
    	AdcaResults[resultsIndex] = 0;
    }
    resultsIndex = 0;         //将存储ADC转换结果的数组清空

    EALLOW;
//take conversions indefinitely in loop
    do{
    	//enable ADCINT flags
    	AdcaRegs.ADCINTSEL1N2.bit.INT1E = 1;
    	AdcaRegs.ADCINTSEL1N2.bit.INT2E = 1;
    	AdcaRegs.ADCINTSEL3N4.bit.INT3E = 1;
    	AdcaRegs.ADCINTSEL3N4.bit.INT4E = 1;
		AdcaRegs.ADCINTFLGCLR.all = 0x000F;   //开启中断，清除中断标志

    	//initialize results index
    	resultsIndex = 0;
    	//software force start SOC0 to SOC7
    	AdcaRegs.ADCSOCFRC1.all = 0x00FF;     //启动SOC0-SOC7
    	//keep taking samples until the results buffer is full
    	
    	while(resultsIndex < RESULTS_BUFFER_SIZE)
    	{
    		//wait for first set of 8 conversions to complete
    		while(0 == AdcaRegs.ADCINTFLG.bit.ADCINT3);
    		//clear both INT flags generated by first 8 conversions
    		AdcaRegs.ADCINTFLGCLR.bit.ADCINT1 = 1;
    		AdcaRegs.ADCINTFLGCLR.bit.ADCINT3 = 1;

    		//save results for first 8 conversions
    		//
    		//note that during this time, the second 8 conversions have
    		//already been triggered by EOC6->ADCIN1 and will be actively
    		//converting while first 8 results are being saved
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT0;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT1;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT2;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT3;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT4;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT5;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT6;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT7;

    		//wait for the second set of 8 conversions to complete
    		while(0 == AdcaRegs.ADCINTFLG.bit.ADCINT4);
    		//clear both INT flags generated by second 8 conversions
    		AdcaRegs.ADCINTFLGCLR.bit.ADCINT2 = 1;
    		AdcaRegs.ADCINTFLGCLR.bit.ADCINT4 = 1;

    		//save results for second 8 conversions
    		//
    		//note that during this time, the first 8 conversions have
    		//already been triggered by EOC14->ADCIN2 and will be actively
    		//converting while second 8 results are being saved
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT8;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT9;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT10;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT11;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT12;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT13;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT14;
    		AdcaResults[resultsIndex++] = AdcaResultRegs.ADCRESULT15;
    	}

    	//disable all ADCINT flags to stop sampling
    	AdcaRegs.ADCINTSEL1N2.bit.INT1E = 0;
    	AdcaRegs.ADCINTSEL1N2.bit.INT2E = 0;
    	AdcaRegs.ADCINTSEL3N4.bit.INT3E = 0;
    	AdcaRegs.ADCINTSEL3N4.bit.INT4E = 0;

    	//at this point, AdcaResults[] contains a sequence of conversions
    	//from the selected channel

    	//software breakpoint, hit run again to get updated conversions
//    	asm("   ESTOP0");
    	DELAY_US(1000);
    }while(1);
}
  • 1.进入循环，启动SOC0-SOC7。
  • 2.开启中断，清空中断标志位。
  • 3.当数组未装满时，等待INT3触发（即SOC0-SOC7完成转换），[SOC6完成后会触发INT1中断，INT1中断会触发SOC8-SOC15进行转换]。
  • 4.存储SOC0-SOC7的转换结果，再等待INT4触发(即SOC8-SOC15完成转换)，[SOC14完成后会触发INT2中断，INT2中断会触发SOC0-SOC7进行转换]。
	__interrupt void epwm1_isr(void)
{
    // Update the CMPA and CMPB values
    update_compare(&epwm1_info);

    // Clear INT flag for this timer
    EPwm1Regs.ETCLR.bit.INT = 1;

    // Acknowledge this interrupt to receive more interrupts from group 3
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}

  update_compare(&epwm1_info)中改变EPWM1的相关参数（如CMPA和CMPB的值等）与本文的主要目的关系不大，这里不做主要介绍。

void update_compare(EPWM_INFO *epwm_info)
{
   // Every 10'th interrupt, change the CMPA/CMPB values
   if(epwm_info->EPwmTimerIntCount == 10)
   {
       epwm_info->EPwmTimerIntCount = 0;

       // If we were increasing CMPA, check to see if
       // we reached the max value.  If not, increase CMPA
       // else, change directions and decrease CMPA
	   if(epwm_info->EPwm_CMPA_Direction == EPWM_CMP_UP)
	   {
	       if(epwm_info->EPwmRegHandle->CMPA.bit.CMPA < epwm_info->EPwmMaxCMPA)
	       {
	          epwm_info->EPwmRegHandle->CMPA.bit.CMPA++;
	       }
	       else
	       {
	          epwm_info->EPwm_CMPA_Direction = EPWM_CMP_DOWN;
              epwm_info->EPwmRegHandle->CMPA.bit.CMPA--;
	       }
	   }

	   // If we were decreasing CMPA, check to see if
       // we reached the min value.  If not, decrease CMPA
       // else, change directions and increase CMPA
	   else
	   {
	       if(epwm_info->EPwmRegHandle->CMPA.bit.CMPA == epwm_info->EPwmMinCMPA)
	       {
	          epwm_info->EPwm_CMPA_Direction = EPWM_CMP_UP;
	          epwm_info->EPwmRegHandle->CMPA.bit.CMPA++;
	       }
	       else
	       {
	          epwm_info->EPwmRegHandle->CMPA.bit.CMPA--;
	       }
	   }

	   // If we were increasing CMPB, check to see if
       // we reached the max value.  If not, increase CMPB
       // else, change directions and decrease CMPB
	   if(epwm_info->EPwm_CMPB_Direction == EPWM_CMP_UP)
	   {
	       if(epwm_info->EPwmRegHandle->CMPB.bit.CMPB < epwm_info->EPwmMaxCMPB)
	       {
	          epwm_info->EPwmRegHandle->CMPB.bit.CMPB++;
	       }
	       else
	       {
	          epwm_info->EPwm_CMPB_Direction = EPWM_CMP_DOWN;
	          epwm_info->EPwmRegHandle->CMPB.bit.CMPB--;
	       }
	   }

	   // If we were decreasing CMPB, check to see if
       // we reached the min value.  If not, decrease CMPB
       // else, change directions and increase CMPB
	   else
	   {
	       if(epwm_info->EPwmRegHandle->CMPB.bit.CMPB == epwm_info->EPwmMinCMPB)
	       {
	          epwm_info->EPwm_CMPB_Direction = EPWM_CMP_UP;
	          epwm_info->EPwmRegHandle->CMPB.bit.CMPB++;
	       }
	       else
	       {
	          epwm_info->EPwmRegHandle->CMPB.bit.CMPB--;
	       }
	   }
   }
   else
   {
      epwm_info->EPwmTimerIntCount++;
   }

   return;
}

三、总结

   由以上程序可以看出，CPU2运行外设没有其他特别的步骤。主要还是需要在CPU1中对外设的归属进行声明以及初始化相关的GPIO。

    /CPU1中程序/
	InitEPwm1Gpio();//
	EALLOW;
    DevCfgRegs.CPUSEL0.bit.EPWM1 = 1;//connect to CPU2
    DevCfgRegs.CPUSEL11.bit.ADC_A = 1;//connect to CPU2
    EDIS;

四、致谢

  代码均来自与TI公司例程，本人仅做了整理和分析。我所使用的例程链接贴一下：双核例程

Quikk
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
28377D中CPU2操作EMIF1要点
11-30 1369
默认情况下，EMIF1的写操作权限属于CPU1，如果想CPU2操作EMIF1，需要将权限交给CPU2： 1.EMIF1MSEL寄存器的KEY位域写0x93A5CE7；这是为了允许对MSEL_EMIF1位域的操作； 2. EMIF1MSEL寄存器的MSEL_EMIF1位域写10；这是将EMIF1的权限交给CPU2。 需要注意的是：KEY位与MSEL_EMIF1必须一次写入，如果单独写入的话CPU就不响应了。而且CPU1里面无法将EMIL1的写权限配置给CPU2 配置如下： EALLOW;Emi.
TMS320F2837xD软件编程设计之CPU1应用相关设置
最新发布
卡尔二叔
04-24 608
TMS320F2837xD软件编程设计之CPU1应用相关设置说明
DSP2837xD视频教程.zip
05-28
workshop_vedio的DSP28377D的学习视频，资源宝贵，适合学习C2000系列28377D双核dsp的人观看学习
TMS320F28377xD技术参考手册中文翻译dsp
03-06
TMS320F28377xD技术参考手册中文翻译dsp，technical reference manual手册中文翻译
2837xd代码生成模块学习（2）——ADC、ePWM模块、Timer0
qq_42151264的博客
07-17 3193
2837xd代码生成模块学习（2）——ADC、ePWM模块、Timer01 ADC模块2 Timer0中断3 ePWM模块配置 模型链接： 1 ADC模块 模型结构： 以上结构完成了经过ADC采集，进行输出采集到的电压的过程。 1）ADC采集模块 2）SCI_A的采集配置见文章（链接） 3）Configuration Parameters中配置ADC(根据需要进行配置)   这里说一下，2837x的ADC采集较28335的ADC有所改动。总体来说我感觉是更加方便使用，具体的用法建议参考用户手册或者T
TMS320F2837xD 双核微控制器中文手册
10-31
总的来说，TMS320F2837xD双核微控制器以其强大的处理能力、丰富的外设接口、先进的模拟功能以及对功能安全的支持，成为高要求工业应用的理想选择。无论是实时计算、通信连接还是控制任务，它都能提供出色的表现和...
TMS320F2837xD中文手册 技术手册资料合集.rar
08-10
《TMS320F2837xD中文手册》技术手册资料合集是一份针对数字信号处理器（DSP）的专业参考资料，主要涵盖了Texas ...《TMS320F2837xD中文手册》是学习和使用该芯片不可或缺的参考资料，能为工程师提供全面的技术支持。
TMS320F2837xD中文手册
03-12
1. **高性能CPU内核**：TMS320F2837xD采用增强型C28x+内核，支持高达150MHz的运行频率，提供高效的计算能力。 2. **浮点单元**：内置浮点运算单元（FPU），能快速执行浮点运算，对于需要大量浮点运算的应用如控制...
TMSF2837xD中文程序员参考技术手册
04-23
《TMSF2837xD中文程序员参考技术手册》是TI（Texas Instruments）公司针对其数字信号处理器（DSP）TMSF28377D发布的一份详尽的技术文档，旨在为国内开发者提供方便易懂的编程和寄存器操作指南。这份手册中文版的出现...
DSP28379D_双核启动简介
haoliang的博客
03-26 6569
双核启动简介DSP的上电过程、Boot Mode、Boot Loader，以及双核的调试、烧写。
DSP_TMS320F28377D_ADC学习笔记
heqiunong的专栏
02-28 8124
DSP各种模块的使用，基本上就是 GPIO复用配置、相关控制寄存器的配置、中断的配置。本文主要记录本人对ADC模块的学习笔记。TMS320F28377D上面有24路ADC专用IO，这意味着不需要进行GPIO复用配置。只需要考虑相关控制寄存器和中断的配置。看代码请直接跳到最后。
7. ADC采样
weixin_56587640的博客
12-08 1096
ADC模块是一个逐次逼近(SAR)型ADC，分辨率可选择为16位或12位。ADC由内核和封装器组成。核心由模拟电路组成，包括通道选择MUX、采样保持(S/H) 电路、逐次近电路、基准电压源电路和其他模拟支持电路。封装器由配置和控制模数转换器的数字电路组成。这些电路包括用于可编程转换的逻辑、结果寄存器、到模拟电路的接口、到外围总线的接口、后处理电路以及到其他片上模块的接口。每个ADC模块由单个采样保持 (S/H) 电路组成。ADC模块设计为在同一芯片上重复多次，允许同时采样或独立操作多个ADC。
DELAY_US(1000*200)以及28379D双CPU运行GPIO配置问题
blueoce的博客
12-08 645
DELAY_US(1000*200);要在ram中运行，如果CMD是flash，那么就不能运行，需要放开flash copy 头RAM那段代码，这个在七年前遇到过，时间长了给忘了。现在又遇到了。 28379D双CPU运行时，GPIO 外设的配置是放在CPU1中的，因为GPIO外设寄存器的配置无需每个CPU都有控制权，如果CPU也要用GIPO作为输出输入口，那么让CPU1一下就行。 像这样的函数： GPIO_SetupPinMux(34,...
2837xd 代码生成——StateFlow（2）
qq_42151264的博客
07-29 1652
2837xd 代码生成——StateFlow（2）3 Matlab-Function4 Graphical Function5 Simulink Function6 内部转移（历史节点）7 Box模块8 自循环9 枚举类型10 矩阵 3 Matlab-Function   StateFlow模块也可以调用Matlab-Function的功能，点击左侧栏的Matlab-Function图标，构建以下的函数模型：   双击Matlab-Function，可以直接进行相关的函数定义。函数定义方式参照，m语言的函
TMS2833X之ePWM模块_2
dby3579的专栏
12-17 6627
上一篇讲述到F2833x系列ePWM模块的作用即结构，以及介绍了ePWM模块中的子模块DB时间基准模块，起主要作用是决定PWM波形的周期，以及输出一系列事件（如CTR=ZERO）等供其他模块使用，下面接着介绍ePWM中的其他子模块。 1.ePWM 计数比较模块CC 计数器比较模块是以时基计数器的值作为输入，与比较寄存器CMPA和CMPB不断进行比较，当时基计数器的值等于CMPA时，就产生比较事件...
DSP_CPU_Example_2833x_CpuTimer
aiqiaoqing3630的博客
05-05 569
中斷副程式的宣告 __interrupt void cpu_timer0_isr(void); 進入副程式 __interrupt void cpu_timer0_isr(void) { CpuTimer0.InterruptCount++; // Acknowledge this interrupt to re...
TMS320F28335项目开发记录8_28335之GPIO引脚
热门推荐
SCOTT 技术博客
11-07 1万+
DSP28335 GPIO模块分为三类IO口：PORTA(0-31),PORTB(32-63),PORTC(64-87) 对GPIO模块的设置主要通过三类寄存器来完成，分别是：控制寄存器、数据寄存器、中断寄存器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Quikk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值