我的5509A之路

MEMORY 

{

        MMR     : origin = 0000000h, length = 00000c0h

        SPRAM   : origin = 00000c0h, length = 0000040h

        VECS0   : origin = 0000100h, length = 0000100h

        VECS1   : origin = 0000200h, length = 0000100h

        DARAM0  : origin = 0000300h, length = 0003D00h

        DARAM1  : origin = 0004000h, length = 0004000h

        DARAM2  : origin = 0008000h, length = 0004000h

        DARAM3  : origin = 000c000h, length = 0004000h



        SARAM0  : origin = 0010000h, length = 0004000h

        SARAM1  : origin = 0014000h, length = 0008000h

       /* SARAM2  : origin = 0018000h, length = 0004000h */

        SARAM3  : origin = 001c000h, length = 0004000h

        SARAM4  : origin = 0020000h, length = 0004000h

        SARAM5  : origin = 0024000h, length = 0004000h

        SARAM6  : origin = 0028000h, length = 0004000h

        SARAM7  : origin = 002c000h, length = 0004000h

        SARAM8  : origin = 0030000h, length = 0004000h

        SARAM9  : origin = 0034000h, length = 0004000h

        SARAM10 : origin = 0038000h, length = 0004000h

        SARAM11 : origin = 003c000h, length = 0004000h

        SARAM12 : origin = 0040000h, length = 0004000h

        SARAM13 : origin = 0044000h, length = 0004000h

        SARAM14 : origin = 0048000h, length = 0004000h

        SARAM15 : origin = 004c000h, length = 0004000h



        CE0     : origin = 0050000h, length = 03b0000h

        CE1     : origin = 0400000h, length = 0400000h

        CE2     : origin = 0800000h, length = 0400000h

        CE3     : origin = 0c00000h, length = 03f8000h



        PDROM   : origin = 0ff8000h, length = 07f00h

}



SECTIONS

{

    /* 存放程序区 */

     vectors:    {} > VECS0          /* vectors是在rts55x.lib中定义的 */

    .vectors:   {} > VECS1           /* interrupt vector table */

    .cinit:     {} > SARAM0          /* 变量初值和常量 */

    .text:      {} > SARAM1          /* C程序代码 */



    /* 存放数据区 */

    .csldata:    {} > DARAM0          /* csl库 */

    .bss:        {} > DARAM0         /* 全局和静态变量 */

    .const:      {} > DARAM0         /* 字符、浮点常量和用const声明的常量 */

    .data:       {} > DARAM0

    .cio:        {} > DARAM1

    .stack:      {} > DARAM1         /* 保持返回地址，函数间的参数传递，存储局部变量和中间结果 */

    .sysstack:    {} > DARAM1

    .sysmem:     {} > DARAM2         /* malloc,calloc和realloc函数动态分配的存储空间 */

}

#include "csl.h"

#include "csl_gpio.h"



void delay();



void main(void)

{

     /* 初始化CSL库 */

    CSL_init();

    /* 确定方向为输出 */

    GPIO_pinDirection(GPIO_PIN1, GPIO_OUTPUT);

        /* 循环闪烁 */

           while (1)

           {

                   GPIO_pinWrite(GPIO_PIN1, 1);

                   delay();

                   GPIO_pinWrite(GPIO_PIN1, 0);

                   delay();

           }

}

void delay()

{

        Uint32 j = 0, k = 0;

        for(j = 0; j < 0x0D; j++)

        {

                for(k= 0; k<0xffff; k++)

                {}

        }

}

#include "csl.h"

#include "csl_pll.h"

#include "csl_gpio.h"



void delay();

/*锁相环的设置*/

PLL_Config  myConfig      = {

  0,    //IAI: the PLL locks using the same process that was underway

                //before the idle mode was entered

  1,    //IOB: If the PLL indicates a break in the phase lock,

                //it switches to its bypass mode and restarts the PLL phase-locking

                //sequence

  24,    //PLL multiply value; multiply 24 times

  1             //Divide by 2 PLL divide value; it can be either PLL divide value

                //(when PLL is enabled), or Bypass-mode divide value

                //(PLL in bypass mode, if PLL multiply value is set to 1)

};



void main(void)

{

        /* 初始化CSL库 */

    CSL_init();

    /* 设置系统的运行速度为144MHz */

    PLL_config(&myConfig);

    /* 确定方向为输出 */

    GPIO_pinDirection(GPIO_PIN1, GPIO_OUTPUT);

        /* 循环闪烁 */

           while (1)

           {

                   GPIO_pinWrite(GPIO_PIN1, 1);

                   delay();

                   GPIO_pinWrite(GPIO_PIN1, 0);

                   delay();

           }

}

void delay()

{

        Uint32 j = 0, k = 0;

        for(j = 0; j < 0x0D; j++)

        {

                for(k= 0; k<0xffff; k++)

                {}

        }

}

#include "csl.h"

#include "csl_irq.h"

#include "csl_timer.h"

#include "csl_chip.h"

#include "csl_gpio.h"



//---------Global data definition---------

#define TIMER_CTRL    TIMER_TCR_RMK(\

                      TIMER_TCR_IDLEEN_DEFAULT,    /* IDLEEN == 0 */ \

                      TIMER_TCR_FUNC_OF(0),        /* FUNC   == 0 */ \

                      TIMER_TCR_TLB_RESET,         /* TLB    == 1 */ \

                      TIMER_TCR_SOFT_BRKPTNOW,     /* SOFT   == 0 */ \

                      TIMER_TCR_FREE_WITHSOFT,     /* FREE   == 0 */ \

                      TIMER_TCR_PWID_OF(0),        /* PWID   == 0 */ \

                      TIMER_TCR_ARB_RESET,         /* ARB    == 1 */ \

                      TIMER_TCR_TSS_START,         /* TSS    == 0 */ \

                      TIMER_TCR_CP_PULSE,          /* CP     == 0 */ \

                      TIMER_TCR_POLAR_LOW,         /* POLAR  == 0 */ \

                      TIMER_TCR_DATOUT_0           /* DATOUT == 0 */ \

)



/* Create a TIMER configuration structure that can be passed */

/* to TIMER_config CSL function for initialization of Timer  */

/* control registers.                                        */

TIMER_Config timCfg0 = {

   TIMER_CTRL,               /* TCR0 */

   0x3400u,                  /* PRD0 */

   0x0000                    /* PRSC */

};



//---------Function prototypes---------

/* Reference start of interrupt vector table   */

/* This symbol is defined in file, vectors_timer1.s55 */

extern void VECSTART(void);



/* Function/ISR prototypes */

interrupt void timer0Isr(void);

void taskFxn(void);





/* Create a TIMER_Handle object for use with TIMER_open */

TIMER_Handle mhTimer0;



Uint16 eventId0;

volatile Uint16 timer0_cnt = 0;

int old_intm;

Uint16 tim_val;



//---------main routine---------

void main(void)

{

        /* Initialize CSL library */

        CSL_init();



        /* Set IVPH/IVPD to start of interrupt vector table */

        /* 修改寄存器IVPH，IVPD，重新定义中断向量表 */

        IRQ_setVecs((Uint32)(&VECSTART));



        /* Call function to set timer */

        taskFxn();

    GPIO_pinDirection(GPIO_PIN4, GPIO_OUTPUT);

        while(1)

        {



        }

}



void taskFxn(void)

{

    /* Temporarily disable all maskable interrupts */

        /* 禁止所有可屏蔽的中断源 */

    old_intm = IRQ_globalDisable();



    /* Open Timer 0, set registers to power on defaults */

    /* 打开定时器0，设置其为上电的的默认值，并返回其句柄 */

    mhTimer0 = TIMER_open(TIMER_DEV0, TIMER_OPEN_RESET);



    /* Get Event Id associated with Timer 0, for use with */

    /* CSL interrupt enable functions.                    */

    /* 获取定时器0的中断ID号 */

    eventId0 = TIMER_getEventId(mhTimer0);



    /* Clear any pending Timer interrupts */

    /* 清除定时器0的中断状态位 */

    IRQ_clear(eventId0);



    /* Place interrupt service routine address at */

    /* associated vector location */

    /* 为定时器0设置中断服务程序 */

    IRQ_plug(eventId0,&timer0Isr);



    /* Write configuration structure values to Timer control regs */

    TIMER_config(mhTimer0, &timCfg0);



    /* Enable Timer interrupt */

    IRQ_enable(eventId0);



    /* Enable all maskable interrupts */

    IRQ_globalEnable();



    /* Start Timer */

    TIMER_start(mhTimer0);

}



interrupt void timer0Isr(void)

{

    ++timer0_cnt;

        if (timer0_cnt == 1)

        {

                GPIO_pinWrite(GPIO_PIN4, 1);

        }

    if (timer0_cnt == 200)

    {

                GPIO_pinWrite(GPIO_PIN4, 0);

    }

    if (timer0_cnt == 400)

    {

            timer0_cnt = 0;

    }

}

#include <csl.h>

#include <csl_rtc.h>

#include <csl_irq.h>



//---------Function prototypes---------

/* Reference start of interrupt vector table   */

/* This symbol is defined in file, vectors_timer1.s55 */

extern void VECSTART(void);



/* Function/ISR prototypes */

void RTC_UpdateIsr(void);



RTC_Config getConfig;

RTC_Config myConfig = {

     0x59,    /* rtcsec   */

     0x00,    /* rteseca  */

     0x21,    /* rtcmin   */

     0x00,    /* rtcmina  */

     0x10,    /* rtchour  */

     0x00,    /* rtchoura */

     0x04,    /* rtcdayw  */

     0x05,    /* rtcdaym  */

     0x03,    /* rtcmonth */

     0x15,    /* rtcyear  */

     0x00,    /* rtcpintr */

     0x82,    /* rtcinten */

     0x00     /* rtcintfl */

};



RTC_Date getDate = {

                0,

                0,

                0

};

RTC_Time getTime = {

                0,

                0,

                0

};



RTC_IsrAddr addr = {

        NULL,

        NULL,

        RTC_UpdateIsr

};



volatile Uint16 sec = 0;

volatile Uint16 set_b = 0;

int old_intm;

int eventId;



void main(void)

{

    CSL_init();



    RTC_reset();

    RTC_config(&myConfig);  // Initialization



    set_b = RTC_FGET(RTCINTEN, SET);



        /* 修改寄存器IVPH，IVPD，重新定义中断向量表 */

        IRQ_setVecs((Uint32)(&VECSTART));



    /* 禁止所有可屏蔽的中断源 */

    old_intm = IRQ_globalDisable();



    /* 获取RTC的中断ID号 */

    eventId = RTC_getEventId();



    /* 清除RTC的中断状态位 */

    IRQ_clear(eventId);



    /* Place interrupt service routine address at

       associated vector location */

    RTC_setCallback(&addr);



    /* Enable RTC maskable interrupts */

    IRQ_enable(eventId);



    /* Enable all maskable interrupts */

    IRQ_globalEnable();



    sec = RTC_RGET(RTCSEC);



    /* Start RTC */

    RTC_start();



        /* Read the current time from the RTC register */

    RTC_getTime(&getTime);

    RTC_getDate(&getDate);

    set_b = RTC_FGET(RTCINTEN, SET);



    while (sec != 0)

    {

        sec = RTC_RGET(RTCSEC);

    }



    /* Enable Update interrupt to start */

    RTC_eventEnable(RTC_EVT_UPDATE);



        while (1)

        {



        }

}



void RTC_UpdateIsr(void)

{

        /* Read the current time from the RTC register */

    RTC_getTime(&getTime);

    RTC_getDate(&getDate);

}

#include <csl.h>

#include <csl_pll.h>

#include <csl_adc.h>



PLL_Config  myPLLConfig = {

  0,    //IAI: the PLL locks using the same process that was underway

                //before the idle mode was entered

  1,    //IOB: If the PLL indicates a break in the phase lock,

                //it switches to its bypass mode and restarts the PLL phase-locking

                //sequence

  24,    //PLL multiply value; multiply 24 times

  1             //Divide by 2 PLL divide value; it can be either PLL divide value

                //(when PLL is enabled), or Bypass-mode divide value

                //(PLL in bypass mode, if PLL multiply value is set to 1)

};



ADC_Config myADConfig = {

  0x0000,   // ADCStart = 0, ChSelect = 000.

  0x4f00,        // ADC Sample and Hold Period =

                         // (1 / (ADC Clock)) / (2 
(CONVRATEDIV + 1 + SAMPTIMEDIV))

                         // = (1 / (4 MHz)) / (2 
(0 + 1 + SAMPTIMEDIV))

                         // = 250 ns 
 (2 
(0 + 1 + 79)) = 40 μs

                         // ADC Conversion Clock = (4 MHz) / (2 
(0 + 1)) = 2 MHz

  0x0023    // ADC Clock = (144 MHz) / (35 + 1) = 4 MHz;

};



void main(void)

{

        volatile Uint16 average = 0;

        Uint16 samplestorage[8] = {0};

        Uint8 i = 0;

        Uint16 sum = 0;



    CSL_init();



    /* 设置系统的运行速度为144MHz */

    PLL_config(&myPLLConfig);



    /* 设置ACD的运行速度 */

    ADC_config(&myADConfig);



        while(1)

        {

                /* samplestorage array. */

                ADC_read(0, samplestorage, 8);



                for (i = 0; i < 8; i++)

                {

                        sum += samplestorage[0];

                }

                average = sum / 8;

                average = 0;

                sum = 0;

        }

}

#include "csl.h"

#include "csl_pll.h"

#include "csl_emif.h"

#include "csl_chip.h"



/*锁相环的设置*/

PLL_Config  myConfig      = {

  0,    //IAI: the PLL locks using the same process that was underway

                //before the idle mode was entered

  1,    //IOB: If the PLL indicates a break in the phase lock,

                //it switches to its bypass mode and restarts the PLL phase-locking

                //sequence

  24,    //PLL multiply value; multiply 24 times

  1             //Divide by 2 PLL divide value; it can be either PLL divide value

                //(when PLL is enabled), or Bypass-mode divide value

                //(PLL in bypass mode, if PLL multiply value is set to 1)

};

/*SDRAM的EMIF设置*/

void sdram_init(void)

{

    ioport unsigned int *ebsr  = (unsigned int *)0x6c00;

    ioport unsigned int *egcr  = (unsigned int *)0x0800;

    ioport unsigned int *emirst = (unsigned int *)0x0801;

    // ioport unsigned int *emibe = (unsigned int *)0x0802;

    ioport unsigned int *ce01  = (unsigned int *)0x0803;

    ioport unsigned int *ce02  = (unsigned int *)0x0804;

    ioport unsigned int *ce03  = (unsigned int *)0x0805;

    ioport unsigned int *ce11  = (unsigned int *)0x0806;

    ioport unsigned int *ce12  = (unsigned int *)0x0807;

    ioport unsigned int *ce13  = (unsigned int *)0x0808;

    ioport unsigned int *ce21  = (unsigned int *)0x0809;

    ioport unsigned int *ce22  = (unsigned int *)0x080A;

    ioport unsigned int *ce23  = (unsigned int *)0x080B;

    ioport unsigned int *ce31  = (unsigned int *)0x080C;

    ioport unsigned int *ce32  = (unsigned int *)0x080D;

    ioport unsigned int *ce33  = (unsigned int *)0x080E;

    ioport unsigned int *sdc1  = (unsigned int *)0x080F;

    ioport unsigned int *sdper = (unsigned int *)0x0810;

    // ioport unsigned int *sdcnt = (unsigned int *)0x0811;

    ioport unsigned int *init  = (unsigned int *)0x0812;

    ioport unsigned int *sdc2  = (unsigned int *)0x0813;

        ioport unsigned int *sdc3  = (unsigned int *)0x0814;  // 此寄存器只用于5510,5509中无



    *ebsr   = 0x0201;    // full emif 23d

    *egcr   = 0x0210;         //  230  210

                         // EGCR  : the MEMFREQ = 001

                                 //         the MEMCEN = 0, 最后置‘1’

                                 //         ARDYOFF = 1, 不使用异步



    *ce01   = 0x3FFF;        // CE0_1:  CE0 space control register 1

                                //         MTYPE = 011, Synchronous DRAM (SDRAM), 16-bit data bus width

    *ce02   = 0xFFFF;   // CE0_2:  CE0 space control register 2

    *ce03   = 0x00FF;   // CE0_3:  CE0 space control register 3



    *ce11   = 0x3FFF;        // CE1_1:  CE1 space control register 1

                                //         MTYPE = 011, Synchronous DRAM (SDRAM), 16-bit data bus width

    *ce12   = 0xFFFF;   // CE1_2:  CE1 space control register 2

    *ce13   = 0x00FF;   // CE1_3:  CE1 space control register 3



    *ce21   = 0x7FFF;        // CE0_1:  CE2 space control register 1

    *ce22   = 0xFFFF;   // CE0_2:  CE2 space control register 2

    *ce23   = 0x00FF;   // CE0_3:  CE2 space control register 3



    *ce31   = 0x7FFF;        // CE3_1:  CE3 space control register 1

    *ce32   = 0xFFFF;   // CE3_2:  CE3 space control register 2

    *ce33   = 0x00FF;   // CE3_3:  CE3 space control register 3



    *emirst = 0xFFFF;    // EMIRST: any write to this register resets the EMIF state machine

    *sdc1   = 0x2911;

    *sdc2   = 0x0131;

    *sdc3   = 0x0003;   //

    *sdper  = 0x0410;



    *egcr   = *egcr | 0x0020;     // the MEMCEN = 1

    *init   = 0xFFFF;

}



void main(void)

{

        volatile int *SourceAddr = (int *)0x40000;

        int i = 0;



        /*初始化CSL库*/

    CSL_init();



    /*初始化DSP的外部SDRAM*/

    sdram_init();



    /*设置系统的运行速度为144MHz*/

    PLL_config(&myConfig);



    /*向SDRAM中写入数据*/

    for (i = 0; i < 1000; i++)

    {

             *SourceAddr++ = i;

    }



    while(1);

}

#include "csl.h"

#include "csl_pll.h"

#include "csl_chip.h"

#include "csl_gpio.h"



Uint16 eventId0;

int old_intm;



interrupt void int1(void);



//---------Function prototypes---------



/* Reference start of interrupt vector table   */



/* This symbol is defined in file, vectors.s55 */



extern void VECSTART(void);





/*锁相环的设置*/

PLL_Config  myConfig      = {

  0,    //IAI: the PLL locks using the same process that was underway

                //before the idle mode was entered

  1,    //IOB: If the PLL indicates a break in the phase lock,

                //it switches to its bypass mode and restarts the PLL phase-locking

                //sequence

  12,    //PLL multiply value; multiply 12 times

  1             //Divide by 2 PLL divide value; it can be either PLL divide value

                //(when PLL is enabled), or Bypass-mode divide value

                //(PLL in bypass mode, if PLL multiply value is set to 1)

};



void INTconfig()

{

    /* Temporarily disable all maskable interrupts */



    IRQ_setVecs((Uint32)(&VECSTART));



        /* Temporarily disable all maskable interrupts */



    old_intm = IRQ_globalDisable();



        /* Get Event Id associated with External INT1(8019), for use with */

        eventId0 = IRQ_EVT_INT0;



        /* Clear any pending INT1 interrupts */



        IRQ_clear(eventId0);



        /* Place interrupt service routine address at */



    /* associated vector location */



    IRQ_plug(eventId0,&int1);



        /* Enable INT1(8019) interrupt */



    IRQ_enable(eventId0);



        /* Enable all maskable interrupts */



    IRQ_globalEnable();



}



void main(void)

{

        /*初始化CSL库*/

    CSL_init();



    /*设置系统的运行速度为144MHz*/

    PLL_config(&myConfig);



        //设置并使能5509A芯片的INT0中断(EXINT中断)

        INTconfig();



    /* IO方向为输出 */

    GPIO_pinDirection(GPIO_PIN0, GPIO_OUTPUT);



        while(1);

}



//External INT0(EXINT)中断处理函数

interrupt void int1()

{

        GPIO_pinWrite( GPIO_PIN0, 0x01 ^ GPIO_pinRead(GPIO_PIN0) );

}