2837xD之IPC通信（共享内存）

IPC通信基本原理

• IPC通信是TI公司的一种双核通信方式，主要有：1.共享内存（Message RAM） 2.共享寄存器（Message register） 3.IPC lite 等等。本次分析的是TI公司的例程（基于2837xD）。

程序部分

一、CPU1程序注释

• 例程目标：

// //###########################################################################
FILE:   RAM_management_cpu01.c
TITLE:  RAM management Example for F2837xD.

//This example shows how to assign shared RAM for use by both the CPU02 
//and CPU01 core.   //使用CPU1与CPU2进行通信
//Shared RAM regions are defined in  both the CPU02 and CPU01 linker files.
// In this example GS0 and GS14 are assigned to/owned by CPU02. The remaining 
// shared RAM regions are owned by CPU01.
//! In this example:
//! 
//! A pattern is written to c1_r_w_array and then IPC flag is sent to notify 
//! CPU02 that data is ready to be read. CPU02 then reads the data from
//! c2_r_array and writes a modified pattern to c2_r_w_array. Once CPU02 acknowledges
//! the IPC flag to , CPU01 reads the data from c1_r_array and compares with expected
//! result.
//! 
//! A Timed ISR is also serviced in both CPUs. The ISRs are copied into the shared 
//! RAM region owned by the respective CPUs. Each ISR toggles a GPIO. Watch GPIO31
//! and GPIO34 on oscilloscope. If using the control card watch LED1 and LED2 blink
//! at different rates.
//!  - c1_r_w_array[] is mapped to shared RAM GS1
//!  - c1_r_array[]   is mapped to shared RAM GS0
//!  - c2_r_array[]   is mapped to shared RAM GS1
//!  - c2_r_w_array[] is mapped to shared RAM GS0
//!  - cpu_timer0_isr in CPU02 is copied to shared RAM GS14 , toggles GPIO31
//!  - cpu_timer0_isr in CPU01 is copied to shared RAM GS15 , toggles GPIO34
//!
//! \b  Watch \b Variables
//!
//!  - error Indicates that the data written is not correctly received by the other CPU.
//
//###########################################################################
// $TI Release: F2837xD Support Library v190 $
// $Release Date: Mon Feb  1 16:51:57 CST 2016 $
// $Copyright: Copyright (C) 2013-2016 Texas Instruments Incorporated -
//             http://www.ti.com/ ALL RIGHTS RESERVED $
//###########################################################################;

以上文档说明指出

• 1.Share RAM 区域需要在CPU1和CPU2的ilnk文件进行定义。
  2.本例中定义GS0和GS14属于CPU2，剩下的空间属于CPU1
  3.数据将被CPU1写入c1_r_w_array数组，然后通过IPC_flag通知CPU2。
  4.CPU2从c2_r_array读取数据，然后将修改后的数据写入c2_r_w_array,然后通过IPC_flag通知CPU1。

二、CPU1主程序部分

#include "F28x_Project.h"
#include "F2837xD_Ipc_drivers.h"

// Data exchange arrays  32*256=2^12
uint16_t c1_r_array[256];  
uint16_t c1_r_w_array[256]; 
#pragma DATA_SECTION(c1_r_array,"SHARERAMGS0"); // 分配到GS0(CPU2)
#pragma DATA_SECTION(c1_r_w_array,"SHARERAMGS1");// 分配到GS1（CPU1）

// Global variables 
uint16_t error;
uint16_t multiplier;

// External variables declared by linker.
extern uint16_t isrfuncLoadStart;
extern uint16_t isrfuncLoadEnd;
extern uint16_t isrfuncRunStart;
extern uint16_t isrfuncLoadSize;

// Prototype statements for functions found within this file.
__interrupt void cpu_timer0_isr(void);
#pragma CODE_SECTION(cpu_timer0_isr,"isrfunc") //中断程序放置到GS14

// Functions to read and write data
void Shared_Ram_dataRead_c1(void);
void Shared_Ram_dataWrite_c1(void);

void main(void)
{
  //1.初始化程序
  InitSysCtrl(); 

#ifdef _STANDALONE
#ifdef _FLASH
  //  Send boot command to allow the CPU02 application to begin execution
  IPCBootCPU2(C1C2_BROM_BOOTMODE_BOOT_FROM_FLASH);
#else
  //  Send boot command to allow the CPU02 application to begin execution
  IPCBootCPU2(C1C2_BROM_BOOTMODE_BOOT_FROM_RAM);
#endif
#endif  //引导CPU2启动

// 2.初始化GPIO:
  InitGpio();  // Skipped for this example

// 3.关中断
  DINT;

// 初始化PIE
 InitPieCtrl();

// 清除中断
 IER = 0x0000;
 IFR = 0x0000;

// 初始化PIE向量表
 InitPieVectTable();
 
// GPIO31属于CPU2
  GPIO_SetupPinMux(31,GPIO_MUX_CPU2,0);
  GPIO_SetupPinOptions(31, GPIO_OUTPUT,0);
  
// GPIO34属于CPU1
  GPIO_SetupPinMux(34,GPIO_MUX_CPU1,0);
  GPIO_SetupPinOptions(34, GPIO_OUTPUT,0);    

// 将GS0和GS14控制权给CPU2
  while( !(MemCfgRegs.GSxMSEL.bit.MSEL_GS0 &
  		 MemCfgRegs.GSxMSEL.bit.MSEL_GS14))
  {
  	EALLOW;
  	MemCfgRegs.GSxMSEL.bit.MSEL_GS0 = 1;//0:CPU1 is master for this memory
  										//1:CPU2 is master for this memory
  	MemCfgRegs.GSxMSEL.bit.MSEL_GS14 = 1;
  	EDIS;
  }

//  将中断函数拷贝进入GS14 RAM空间
  memcpy(&isrfuncRunStart, &isrfuncLoadStart, (uint32_t)&isrfuncLoadSize);

//指定中断函数
  EALLOW;  // This is needed to write to EALLOW protected registers
  PieVectTable.TIMER0_INT = &cpu_timer0_isr;
  EDIS;    // This is needed to disable write to EALLOW protected registers
  
///初始化定时器
 InitCpuTimers();   // For this example, only initialize the Cpu Timers    
 
//设置定时器2s
 ConfigCpuTimer(&CpuTimer0, 200, 2000000); 

//启动定时器
 CpuTimer0Regs.TCR.all = 0x4000; // Use write-only instruction to set TSS bit = 0
 
// 开始中断
 IER |= M_INT1;   
 
// 开PIE
 PieCtrlRegs.PIEIER1.bit.INTx7 = 1;   
 
// Enable global Interrupts and higher priority real-time debug events:
 EINT;   // 开全局中断
 ERTM;   // 开启实时中断  
  // Main Code
  error = 0;
  multiplier = 0;
  Shared_Ram_dataWrite_c1();  //给c1_r_w_array数组中写入数据内容为[0]:multiplier,[1]-[255]=1-255
  IPCLtoRFlagSet(IPC_FLAG10); /挂起中断信号FLAG10
  
  while(1)
  {          
      // 如果没有挂起中断标志（代表CPU2已经操作完毕，ACK了FLAG10）
      if(IPCLtoRFlagBusy(IPC_FLAG10) == 0)
      {
          Shared_Ram_dataRead_c1();  //读取c1_r_array中的数据
          
          if(multiplier++ > 255)
          {
              multiplier = 0;
          }                                   //multipliter++，单只能在0-255中间循环
      
          //给c1_r_w_array数组中写入数据内容为[0]:multiplier,[1]-[255]=1-255
          Shared_Ram_dataWrite_c1();
          IPCLtoRFlagSet(IPC_FLAG10);
      }
  }
}

__interrupt void cpu_timer0_isr(void)
{
 EALLOW;
 CpuTimer0.InterruptCount++;  //记录进入中断次数
 GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1;  //GPIO34翻转
 EDIS;
 PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;   //清除中断标志
}

void Shared_Ram_dataWrite_c1(void)  //写入c1_r_w_array中数据
{
  uint16_t index;

  // Use first location to write a multiplier.
  c1_r_w_array[0] = multiplier;  //0
  
  for(index = 1; index < 256; index++)
  {
      c1_r_w_array[index] = index;
      //the following code will attempt to write to a shared RAM
      //assigned to cpu2 and as a result will cause an error.
      //c1_r_array[index] = 1000 + index;
  }
}

//读取CPU2处理后的数据并进行校验是否进行了乘法
void Shared_Ram_dataRead_c1(void)
{
  uint16_t index;

  if(c1_r_array[0] == multiplier)
  {
     for(index = 1; index < 256; index++)
     {
         if(c1_r_array[index] != multiplier*c1_r_w_array[index])
         {
             error = 1;        
         }
     }
  }
  else
  {
      error = 1;
  }
}

三、CPU2主程序部分

#include "F28x_Project.h"     
#include "F2837xD_Ipc_drivers.h"

uint16_t c2_r_w_array[256];  
uint16_t c2_r_array[256];     
#pragma DATA_SECTION(c2_r_array,"SHARERAMGS1"); //分配给GS1(CPU1)
#pragma DATA_SECTION(c2_r_w_array,"SHARERAMGS0"); //分配给GS0(CPU2)

// External variables declared by linker.
extern uint16_t isrfuncLoadStart;
extern uint16_t isrfuncLoadEnd;
extern uint16_t isrfuncRunStart;
extern uint16_t isrfuncLoadSize;

// Prototype statements for functions found within this file.
__interrupt void cpu_timer0_isr(void);
#pragma CODE_SECTION(cpu_timer0_isr,"isrfunc")

void Shared_Ram_dataWrite_c2(void);// function to write data from shared RAM owned by c2

void main(void)
{

//   InitSysCtrl();


// InitGpio();  // Skipped for this example


 DINT;


 InitPieCtrl();


 IER = 0x0000;
 IFR = 0x0000;


 InitPieVectTable();

// CPU1未分配RAM就一直等待
 while(!( MemCfgRegs.GSxMSEL.bit.MSEL_GS0 &
  	    MemCfgRegs.GSxMSEL.bit.MSEL_GS14 ) )
 {


 }
//  将中断拷贝进入RAM
  memcpy(&isrfuncRunStart, &isrfuncLoadStart, (uint32_t)&isrfuncLoadSize);

 EALLOW;  // This is needed to write to EALLOW protected registers
 PieVectTable.TIMER0_INT = &cpu_timer0_isr;
 EDIS;    // This is needed to disable write to EALLOW protected registers


 InitCpuTimers();   // For this example, only initialize the Cpu Timers

//定时器设置为1s
 ConfigCpuTimer(&CpuTimer0, 200, 1000000);

// 启动定时器
 CpuTimer0Regs.TCR.all = 0x4000; // Use write-only instruction to set TSS bit = 0

// Step 5. User specific code, enable interrupts:

// Enable CPU int1 which is connected to CPU-Timer 0
 IER |= M_INT1;

// Enable TINT0 in the PIE: Group 1 interrupt 7
 PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

// Enable global Interrupts and higher priority real-time debug events:
 EINT;   // Enable Global interrupt INTM
 ERTM;   // Enable Global realtime interrupt DBGM
 
 while(1)
 {
 //如果CPU1挂起了中断线FLAG10
      if(IPCRtoLFlagBusy(IPC_FLAG10) == 1)
      {       
          //Read c2_r_array and modify c2_r_w_array  
          Shared_Ram_dataWrite_c2();     //处理CPU1传送来的信息
       
          IPCRtoLFlagAcknowledge (IPC_FLAG10);            //应答
       }            
 }
}

// function definitions
__interrupt void cpu_timer0_isr(void)  //每1s进入一次中断程序
{
 EALLOW;
 CpuTimer0.InterruptCount++;
 GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1; //灯光闪烁一次
 EDIS;
 PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}

// Read data from c2_r_array written by CPU01 and 
// modify and write into c2_r_w_array
// c2_r_array[0] is used to hold the multiplier value.
void Shared_Ram_dataWrite_c2(void)
{
  uint16_t index;
  uint16_t multiplier;
  
  multiplier = c2_r_array[0];
  c2_r_w_array[0] = multiplier;
  
  for(index = 1; index < 256; index ++)
  {
      c2_r_w_array[index] = multiplier*c2_r_array[index];
  }
}

致谢

本博客仅供记录学习过程和分享学习心得使用，感谢提供源码的公司。

第一次开博客了，想记录一下学习的过程。坐标武汉小硕一名，目前在学习dsp。现在想的是做出双核程序，CPU1跑算法，CPU2通过IPC交互信息后跑通信。