[2기 대전 김호원]Concoeto MCU 4. Timer Inerrupt, IPC통신

안녕하세요 대전 멤버십 21기 김호원 입니다.

이번 포스팅도 Concerto MCU에 대해서 이어서 진행 하겠습니다. 

포스팅 내용은 내부 데이터 전송과 Timer interrupt에 대해서 정리해 보았습니다.

아래 내용의 자료들은 ti.com에서 인용 하였습니다.

Timer interrupt를 살펴 보겠습니다

먼저 M3에는 총 6개의 Timer가 있습니다.

간단하게 사용하는 코드는 다음과 같습니다.

 

#include "inc/hw_ints.h"

#include "inc/hw_memmap.h"

#include "inc/hw_nvic.h"

#include "inc/hw_types.h"

#include "inc/hw_sysctl.h"

#include "driverlib/debug.h"

#include "driverlib/interrupt.h"

#include "driverlib/sysctl.h"

#include "driverlib/timer.h"

 

unsigned long g_ulFlags;

unsigned int timer0=0,timer1=0;

 

void

Timer0IntHandler(void)

{

    TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

    timer0++;

    HWREGBITW(&g_ulFlags, 0) ^= 1;

 

}

 

void

Timer1IntHandler(void)

{

    TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);

    timer1++;

    HWREGBITW(&g_ulFlags, 1) ^= 1;

 

}

 

int

main(void)

{

    HWREG(SYSCTL_MWRALLOW) =  0xA5A5A5A5;

 

    SysCtlClockConfigSet(SYSCTL_SYSDIV_1 | SYSCTL_M3SSDIV_2 | SYSCTL_USE_PLL |

                         (SYSCTL_SPLLIMULT_M & 0x0F));

 

    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);

 

    IntMasterEnable();

 

    TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER);

    TimerConfigure(TIMER1_BASE, TIMER_CFG_32_BIT_PER);

    TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet(SYSTEM_CLOCK_SPEED));

    TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet(SYSTEM_CLOCK_SPEED) / 2);

 

    IntEnable(INT_TIMER0A);

    IntEnable(INT_TIMER1A);

    TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

    TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);

    IntRegister(INT_TIMER0A, Timer0IntHandler);

    IntRegister(INT_TIMER1A, Timer1IntHandler);

 

    TimerEnable(TIMER0_BASE, TIMER_A);

    TimerEnable(TIMER1_BASE, TIMER_A);

 

    while(1)

    {

    }

}

 

 

인터럽트 주기는 다음과 같이 설정을 해주게 되면 TIMER0는 1Hz로 동작하고 TIMER1은 2Hz로 동작을 하게 됩니다

TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet(SYSTEM_CLOCK_SPEED));

TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet(SYSTEM_CLOCK_SPEED) / 2);

 

Timer1변수가 timer0변수보다 2배 속도로 빠르게 증가 합니다.

 

C28x에는 총 3개의 CPU Timer가 있습니다.

그러나 PIE 테이블에 보면 TIMER0 밖에 표시가 되어 있지 않은데

F28M35x_PieVect.c에 보면 INT13과 14로 표시가 되어있습니다.

 

 

#include "DSP28x_Project.h"

 

#define C28_FREQ    150

 

interrupt void cpu_timer0_isr(void);

interrupt void cpu_timer1_isr(void);

interrupt void cpu_timer2_isr(void);

 

unsigned int timer0,timer1,timer2;

void main(void)

{

    InitSysCtrl();

    DINT;

 

    InitPieCtrl();

 

    IER = 0x0000;

    IFR = 0x0000;

 

    InitPieVectTable();

 

    EALLOW;

    PieVectTable.TINT0 = &cpu_timer0_isr;

    PieVectTable.TINT1 = &cpu_timer1_isr;

    PieVectTable.TINT2 = &cpu_timer2_isr;

 

    EDIS;

    InitCpuTimers();

 

    ConfigCpuTimer(&CpuTimer0, C28_FREQ, 1000000);

    ConfigCpuTimer(&CpuTimer1, C28_FREQ, 2000000);

    ConfigCpuTimer(&CpuTimer2, C28_FREQ, 500000);

 

 

    CpuTimer0Regs.TCR.all = 0x4000;

    CpuTimer1Regs.TCR.all = 0x4000;

    CpuTimer2Regs.TCR.all = 0x4000;

 

    IER |= M_INT1;

    IER |= M_INT13;

    IER |= M_INT14;

 

    PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

 

    EINT;

    ERTM;

 

    for(;;) ;

 

}

 

interrupt void cpu_timer0_isr(void)

{

    CpuTimer0.InterruptCount++;

    timer0++;

    PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;

}

 

interrupt void cpu_timer1_isr(void)

{

    CpuTimer1.InterruptCount++;

    timer1++;

    EDIS;

}

 

interrupt void cpu_timer2_isr(void)

{

    EALLOW;

    CpuTimer2.InterruptCount++;

    timer2++;

    EDIS;

}

 

ConfigCpuTimer(&CpuTimer0, C28_FREQ, 1000000);

ConfigCpuTimer(&CpuTimer1, C28_FREQ, 2000000);

ConfigCpuTimer(&CpuTimer2, C28_FREQ, 500000);

 

ConfigCpuTimer의 3번째 파라메터로 주기를 설정하게 됩니다. 수치는 us단위로 설정을 하게 됩니다.

 

간단하게 M3와 C28간의 통신에 대해서 보면 몇 가지 방법이 있습니다.

먼저 M3에서는 UART로 데이터를 전송하고 C28은 SCI로 데이터를 전송 하는 방법입니다.

 

 

 

 

 

M3코드

 

#include "DSP28x_Project.h"

 

char m_to_c,c_to_m='1'; 

// m_to_c m3에서 c28로 전송하는 데이터 c_to_m c28에서 m3로 전송하는 데이터

 

void main(void){

 

    EALLOW;

 

// SCI에 클럭 인가

    SysCtrlRegs.PCLKCR0.bit.SCIAENCLK = 1;

    SysCtrlRegs.LOSPCP.bit.LSPCLK = 0;

 

    // SCI 설정을 8-N-1 9600 baud

    SciaRegs.SCICCR.all = 0x07;

    SciaRegs.SCICTL1.all = 0x23;

    SciaRegs.SCIHBAUD = 0x07;

    SciaRegs.SCILBAUD = 0xA0;

 

    while(1) {

               if(SciaRegs.SCIRXST.all & 0x40) //전송 받을 데이터 존재?

                m_to_c = SciaRegs.SCIRXBUF.bit.RXDT; //m_to_c에 저장

              

                       SciaRegs.SCITXBUF = c_to_m; //c_to_c의 데이터를 M3로 데이터 전송

    }

}

 

 

C28코드

#include "DSP28x_Project.h"

 

char m_to_c,c_to_m='1'; 

// m_to_c m3에서 c28로 전송하는 데이터 c_to_m c28에서 m3로 전송하는 데이터

 

void main(void){

 

    EALLOW;

 

// SCI에 클럭 인가

    SysCtrlRegs.PCLKCR0.bit.SCIAENCLK = 1;

    SysCtrlRegs.LOSPCP.bit.LSPCLK = 0;

 

    // SCI 설정을 8-N-1 9600 baud

    SciaRegs.SCICCR.all = 0x07;

    SciaRegs.SCICTL1.all = 0x23;

    SciaRegs.SCIHBAUD = 0x07;

    SciaRegs.SCILBAUD = 0xA0;

 

    while(1) {

               if(SciaRegs.SCIRXST.all & 0x40) //전송 받을 데이터 존재?

                m_to_c = SciaRegs.SCIRXBUF.bit.RXDT; //m_to_c에 저장

              

                       SciaRegs.SCITXBUF = c_to_m; //c_to_c의 데이터를 M3로 데이터 전송

    }

}

 

설정은 위에 보는 것과 같이 간단하게 가능합니다.

디버깅을 두 코어를 동시에 사용할 경우 Debug쪽에 M3와 C28을 클릭하면 각 각에 해당하는 변수의 데이터 값을 확인할 수 있습니다.

 

‘3’과 ‘5’를 보냈을 때의 상태입니다.

 

다음은 SSI와 SPI를 Loopback으로 구성이 되어있는 것을 이용해서 데이터를 전송하는 방법입니다.

M3

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_uart.h"

#include "inc/hw_ints.h"

#include "inc/hw_gpio.h"

#include "inc/hw_nvic.h"

#include "inc/hw_sysctl.h"

#include "driverlib/sysctl.h"

#include "driverlib/ssi.h"

#include "driverlib/interrupt.h"

#include "driverlib/uart.h"

 

unsigned char tmp, send_data=0x01;

 

void main(void){

   

 

    // 보호 해제

    HWREG(SYSCTL_MWRALLOW) = 0xa5a5a5a5;

 

    // 램에 인터럽트 벡터 테이블 저장

    HWREG(NVIC_VTABLE) = 0x20005000;

 

    // PLL설정을  M3 100MHz C28 100MHz

    SysCtlClockConfigSet(SYSCTL_USE_PLL | (SYSCTL_SPLLIMULT_M & 0xA) |

                         SYSCTL_SYSDIV_1 | SYSCTL_M3SSDIV_1 |

                         SYSCTL_XCLKDIV_4);

 

    // C28 레셋

    SysCtlReleaseSubSystemFromReset(SYSCTL_CONTROL_SYSTEM_RES_CNF);

 

    // SSI3에 클럭 인가

    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI3);

 

    // C28x SPI - M3 Slave

    HWREG(SYSCTL_SERPLOOP) = SYSCTL_SERPLOOP_SSI3TOSPIA_M;

 

    SSIDisable(SSI3_BASE);

    SSIConfigSetExpClk(SSI3_BASE, SysCtlClockGet(SYSTEM_CLOCK_SPEED),

                       SSI_FRF_MOTO_MODE_1,

                       SSI_MODE_SLAVE, 10000, 8);

    SSIEnable(SSI3_BASE);

 

    while(1) {

       

        if(!SSIBusy(SSI3_BASE)) { //SSI3이 동작하고 있는지 체크

            // C28로 부터 데이터 읽기

            SSIDataGet(SSI3_BASE, (unsigned long *)&tmp);

            // C28에 send_data 전송

            SSIDataPut(SSI3_BASE, send_data);

        }

    }

 

}

 

C28

#include "DSP28x_Project.h"

 

unsigned char tmp,send_data=0x43;

void main(void){

   

 

    // Allow protected register access

    EALLOW;

 

    // SPI 사용 설정

    SysCtrlRegs.PCLKCR0.bit.SPIAENCLK = 1;

    SysCtrlRegs.LOSPCP.bit.LSPCLK = 2;

 

    //C28을 MASTER로 설정하고 M3의 SSI와 통신 속도 설정을 같게 한다.

    SpiaRegs.SPICCR.all = 0x87;

    SpiaRegs.SPICTL.all = 0x06;

    SpiaRegs.SPIBRR = 0xFF;

    SpiaRegs.SPIPRI.bit.FREE = 1;

 

    while(1) {

        //send_data 전송

        SpiaRegs.SPIDAT = (unsigned short)send_data << 8;

        //RX버퍼에 데이터 존재하는지 체크

        while(!SpiaRegs.SPISTS.bit.INT_FLAG);

        tmp = SpiaRegs.SPIRXBUF; //tmp에 데이터 저장

    }

}

 

동작은 위의 것과 동일하게 하게 됩니다.

마지막으로 IPC통신입니다. Concerto내부에는 IPC통신을 하기 위한 메모리 영역이 있습니다.

내부 구조는 다음과 같은 형태로 구성이 되는데 IPCLite를 사용하면 간편하게 사용을 할 수 있습니다.

C to M의 코드는 다음과 같습니다.

M3

#include "inc/hw_ints.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_nvic.h"

#include "driverlib/sysctl.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_sysctl.h"

#include "inc/hw_ram.h"

#include "inc/hw_ipc.h"

#include "driverlib/gpio.h"

#include "driverlib/interrupt.h"

#include "driverlib/cpu.h"

#include "driverlib/ipc.h"

#include "driverlib/ram.h"

#include "utils/ustdlib.h"

 

 

#define M3_MTOC_PASSMSG 0x2007FFE8  // MTOC 파싱 주소 값

                                   

 

void Error(void);

void FunctionCallNoReturn (void);

unsigned long FunctionCallReturn (unsigned long ulData);

void CtoMIPC1IntHandler(void);

 

unsigned short ErrorFlag;

volatile unsigned short FnCallFlag;

 

unsigned short m3_16;

unsigned int m3_32;

 

void

main(void)

{

 

    unsigned long *pulMsgRam;

 

    // M3- 75MHz C28- 150MHz

    SysCtlClockConfigSet(SYSCTL_SYSDIV_1 | SYSCTL_M3SSDIV_2 | SYSCTL_USE_PLL |

                         (SYSCTL_SPLLIMULT_M & 0x0F));

 

    // M3to C28 메세지랩과 Sx SARM을 초기화 한다.

    RAMMReqSharedMemAccess (S0_ACCESS, SX_M3MASTER);

 

   

    // 보호된 레지스터에 쓸수 있도록 허가함

    HWREG(SYSCTL_MWRALLOW) = 0xA5A5A5A5;

 

    HWREG(RAM_CONFIG_BASE + RAM_O_MSXRTESTINIT1) |= 0x1;

    while((HWREG(RAM_CONFIG_BASE + RAM_O_MSXRINITDONE1)&0x1) != 0x1)

    {

    }

 

    HWREG(RAM_CONFIG_BASE + RAM_O_MTOCCRTESTINIT1) |= 0x1;

    while((HWREG(RAM_CONFIG_BASE + RAM_O_MTOCRINITDONE)&0x1) != 0x1)

    {

    }

 

    //  Tells M3 Core that the vector table is at 0x20005200 now

    HWREG(NVIC_VTABLE) = 0x20005000;

 

    // 와치독 타미머0,1을 정지 시킴

    SysCtlPeripheralDisable(SYSCTL_PERIPH_WDOG0);

    SysCtlPeripheralDisable(SYSCTL_PERIPH_WDOG1);

 

    //  C28을 리셋시킴

    //

    SysCtlReleaseSubSystemFromReset(

        SYSCTL_CONTROL_SYSTEM_RES_CNF|SYSCTL_ANALOG_SYSTEM_RES_CNF);

 

    //  프로세서 인터럽트 활성화

    IntMasterEnable();

 

    //  IPC인터럽트 활성화

    IntEnable(INT_CTOMPIC1);

 

    HWREG(SYSCTL_SRCR0) = 0;

 

    //  보호 레지스터에 접근 금지

    HWREG(SYSCTL_MWRALLOW) = 0;

 

       

        //보내는 데이터 형식과 맞춰서 아래처럼 만들어서 받으면 된다.

    pulMsgRam = (void *)M3_MTOC_PASSMSG;

    pulMsgRam[0] = (unsigned long)&m3_16;

        pulMsgRam[1] = (unsigned long)&m3_32;

 

   

    //데이터를 받을 준비가 되었다고 C28에 알려줌

    IPCMtoCFlagSet(IPC_FLAG17);

 

    for(;;)

    {

       

    }

}

 

 

//*****************************************************************************

// CtoMIPC 인터럽트 핸들러

//*****************************************************************************

void

CtoMIPC1IntHandler (void)

{

    // Continue processing messages

    switch (HWREG(MTOCIPC_BASE + IPC_O_CTOMIPCCOM))

    {

    case IPC_SET_BITS_16:

        IPCLiteCtoMSetBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_32:

        IPCLiteCtoMSetBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_16:

        IPCLiteCtoMClearBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_32:

        IPCLiteCtoMClearBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_16:

        IPCLiteCtoMDataWrite(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_32:

        IPCLiteCtoMDataWrite(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_16_PROTECTED:

        IPCLiteCtoMSetBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_32_PROTECTED:

        IPCLiteCtoMSetBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_16_PROTECTED:

        IPCLiteCtoMClearBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_32_PROTECTED:

        IPCLiteCtoMClearBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_16_PROTECTED:

        IPCLiteCtoMDataWrite_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_32_PROTECTED:

        IPCLiteCtoMDataWrite_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_READ_16:

        IPCLiteCtoMDataRead(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_READ_32:

        IPCLiteCtoMDataRead(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_FUNC_CALL:

        IPCLiteCtoMFunctionCall(IPC_FLAG1, IPC_FLAG32);

        break;

    default:

        ErrorFlag = 1;

        break;

    }

   

        IPCMtoCFlagSet(IPC_FLAG17); //데이터를 받을 준비가 되었다고 C28에 알려줌

 

}

 

C28

#include "DSP28x_Project.h"  

#include "F28M35x_Ipc_drivers.h"

 

#define C28_MTOC_PASSMSG  0x0003FFF4            // MTOC 파싱 주소 값

volatile Uint16 delay;

Uint16 c28_16,ErrorFlag;

Uint32 c28_32;

void

main(void)

{

    Uint32 *pulMsgRam = (void *)C28_MTOC_PASSMSG;

 

 

    DINT;

 

    InitPieCtrl();

 

    IER = 0x0000;

    IFR = 0x0000;

 

    InitPieVectTable();

 

    ErrorFlag = 0;

    c28_16 = 0x1234;

        c28_32 = 0x1234567;

 

    for(;;)

    { 

            while (!IPCMtoCFlagBusy(IPC_FLAG17));  //M3에서 RAM을 사용하고 있는지 체크

            IPCMtoCFlagAcknowledge(IPC_FLAG17);       //C28에서 사용 하겠다고 명령을 날림

       

               // 16-BIT데이터를 M3로 전송

            IPCLiteCtoMDataWrite(IPC_FLAG1, pulMsgRam[0],(Uint32)c28_16,

                                 IPC_LENGTH_16_BITS,

                                 IPC_FLAG32);

                                

            for(delay =0 ; delay < 10000; delay++);

                                

            IPCLiteCtoMDataWrite(IPC_FLAG1, pulMsgRam[1],(Uint32)c28_32,

                                 IPC_LENGTH_32_BITS,

                                 IPC_FLAG32);

    }

}

C28_16,32가 M3_16,32로 전송 된 것을 확인 할 수 있습니다.

C28에서 데이터가 전송이 되게 되면 M3의 CtoMIPC1IntHandler로 데이터가 전송이 되게 됩니다.

M to C를 보게 되면

#include "inc/hw_ints.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_nvic.h"

#include "driverlib/sysctl.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_sysctl.h"

#include "inc/hw_ram.h"

#include "inc/hw_ipc.h"

#include "driverlib/gpio.h"

#include "driverlib/interrupt.h"

#include "driverlib/cpu.h"

#include "driverlib/ipc.h"

#include "driverlib/ram.h"

#include "utils/ustdlib.h"

 

#define M3_CTOM_PASSMSG   0x2007F7E8            // CTOM 파싱 주소 값

volatile int delay;

unsigned short m3_16;

unsigned int m3_32;    

void

main(void)

{

  

    volatile unsigned long ulLoop;

    unsigned long *pulMsgRam;

  

    RamMReqSharedMemAccess (S0_ACCESS, SX_M3MASTER);

 

    HWREG(SYSCTL_MWRALLOW) = 0xA5A5A5A5;

 

    HWREG(RAM_CONFIG_BASE + RAM_O_MSXRTESTINIT1) |= 0x1;

    while((HWREG(RAM_CONFIG_BASE + RAM_O_MSXRINITDONE1)&0x1) != 0x1)

    {

    }

 

    HWREG(RAM_CONFIG_BASE + RAM_O_MTOCCRTESTINIT1) |= 0x1;

    while((HWREG(RAM_CONFIG_BASE + RAM_O_MTOCRINITDONE)&0x1) != 0x1)

    {

    }

 

     HWREG(SYSCTL_MWRALLOW) = 0;

 

    HWREG(NVIC_VTABLE) = 0x20005000;

 

    SysCtlPeripheralDisable(SYSCTL_PERIPH_WDOG0);

    SysCtlPeripheralDisable(SYSCTL_PERIPH_WDOG1);

 

        //  C28을 리셋시킴

    SysCtlReleaseSubSystemFromReset(

        SYSCTL_CONTROL_SYSTEM_RES_CNF | SYSCTL_ANALOG_SYSTEM_RES_CNF);

 

    m3_16 = 0x1234;

        m3_32 = 0x12345678;

    pulMsgRam = (void *)M3_CTOM_PASSMSG;

 

    for(;;)

    {

           while (!IPCCtoMFlagBusy(IPC_FLAG17)) ;  //C28에서 RAM을 사용하고 있는지 체크

              IPCCtoMFlagAcknowledge(IPC_FLAG17); //M3에서 사용 하겠다고 명령을 날림

 

    // 16-BIT데이터를 C28로 전송

    IPCLiteMtoCDataWrite(IPC_FLAG1, pulMsgRam[0],(unsigned long)m3_16,

                         IPC_LENGTH_16_BITS,

                         IPC_FLAG32);     

    //delay

    for(delay =0 ; delay < 100; delay++);

   

    // 32-BIT데이터를 C28로 전송

    IPCLiteMtoCDataWrite(IPC_FLAG1, pulMsgRam[1],(unsigned long)m3_32,

                         IPC_LENGTH_32_BITS,

                         IPC_FLAG32);  

    }

   

 

}

 

C28

//###########################################################################

// FILE:   C28_MTOC_IPC.c

// TITLE:  M to c IPC 데이터 전송

//###########################################################################

 

#include "DSP28x_Project.h"  

#include "F28M35x_Ipc_drivers.h"

 

#define C28_CTOM_PASSMSG  0x0003FBF4            // MTOC 파싱 주소 값

 

interrupt void MtoCIPC1IntHandler(void);

 

volatile Uint16 ErrorFlag;

unsigned short c28_16;

Uint32 c28_32;

       

void

main(void)

{

 

    unsigned long *pulMsgRam;

    DINT;

 

    InitPieCtrl();

 

    IER = 0x0000;

    IFR = 0x0000;

   

    InitPieVectTable();

 

    PieVectTable.MTOCIPC_INT1 = &MtoCIPC1IntHandler;

    EDIS;   

 

    IER |= M_INT11;

 

    PieCtrlRegs.PIEIER11.bit.INTx1 = 1;   

 

    EINT;   

    ERTM; 

   

    EALLOW;

    SysCtrlRegs.PCLKCR0.all = 0;

    EDIS;

 

 

    pulMsgRam = (void *)C28_CTOM_PASSMSG;

    pulMsgRam[0] = (unsigned long)&c28_16;

        pulMsgRam[1] = (unsigned long)&c28_32;

    IPCCtoMFlagSet(IPC_FLAG17);

 

    for(;;)

    {

 

    }

}

 

//*****************************************************************************

// MtoC INT1 인터럽트 핸들러

//*****************************************************************************

 

interrupt void

MtoCIPC1IntHandler (void)

{

    // Continue processing messages

    switch (CtoMIpcRegs.MTOCIPCCOM)

    {

    case IPC_SET_BITS_16:

        IPCLiteMtoCSetBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_32:

        IPCLiteMtoCSetBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_16:

        IPCLiteMtoCClearBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_32:

        IPCLiteMtoCClearBits(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_16:

        IPCLiteMtoCDataWrite(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_32:

        IPCLiteMtoCDataWrite(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_16_PROTECTED:

        IPCLiteMtoCSetBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_SET_BITS_32_PROTECTED:

        IPCLiteMtoCSetBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_16_PROTECTED:

        IPCLiteMtoCClearBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_CLEAR_BITS_32_PROTECTED:

        IPCLiteMtoCClearBits_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_16_PROTECTED:

        IPCLiteMtoCDataWrite_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_WRITE_32_PROTECTED:

        IPCLiteMtoCDataWrite_Protected(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_READ_16:

        IPCLiteMtoCDataRead(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_DATA_READ_32:

        IPCLiteMtoCDataRead(IPC_FLAG1, IPC_FLAG32);

        break;

    case IPC_FUNC_CALL:

        IPCLiteMtoCFunctionCall(IPC_FLAG1, IPC_FLAG32);

        break;

    default:

        ErrorFlag = 1;

        break;

    }

 

    IPCCtoMFlagSet(IPC_FLAG17);

    PieCtrlRegs.PIEACK.all = PIEACK_GROUP11;  

}

 

 

동작은 위의 것과 반대로 동작을 하게 되고 간단하게 사용이 가능합니다 ^^

 

끝까지 읽어 주셔서 감사합니다.