예제 #1
0
파일: main.c 프로젝트: yfang1644/DSP55X
void main(void)
{
	Uint16 key;

	ICR = 0xff2e;	/* IDLE Control Register */
	/* mem port, io port and cpu idle active */

	/* Peripheral_Reset  */
	CSL_SYSCTRL_REGS->PSRCR = 0x0020;

	CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
	CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
	CSL_SYSCTRL_REGS->PRCR = 0x00bf;

/* VERY IMPORTANT !!! */
/* PPMODE1 (SPI, GPIO, UART, and I2S2):
	7 signals of the SPI module,
	6 GPIO signals(GP[17:12]),
	4 signals of the UART module,
	4 signals of the I2S2 module

   SP1MODE2 (GP[11:6]). 6 GPIO signals (GP[11:6])
   SP0MODE0 (MMC/SD0). All 6 signals of the MMC/SD0
*/
	CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
							|(CSL_SYS_EBSR_SP1MODE_MODE2 << 10)
							|(CSL_SYS_EBSR_SP0MODE_MODE0 << 8);

	asm("	bit(ST1, #ST1_INTM) = #1");

	INTR_init();
	PLL_init(160*1000000L);
	TIMER_init();

	EZDSP5535_I2C_init();
	EZDSP5535_LCD_init();
	aic3204_init(2, 0);
	EZDSP5535_GPIO_init();
	EZDSP5535_I2S_init(1);			// interrupt mode
	EZDSP5535_SAR_init();
	asm("	bit(ST1, #ST1_INTM) = #0");

	displayPeriod();
	while(1) {
		key = EZDSP5535_SAR_getKey();
		if(key == SW1) {
			if(period > 10)
				period--;
			CSL_GPIO_REGS->IOOUTDATA2 ^= 2;
			displayPeriod();
		}
		if(key == SW2) {
			if(period < 900)
				period++;
			CSL_GPIO_REGS->IOOUTDATA2 ^= 1;
			displayPeriod();
		}
		asm("   idle");
	}
}
예제 #2
0
void main(void) {
    long op1, op2;   //32-bit operands
    char* ptr;       //pointer to keypad buffer
    char* blanks;
    char kbuf[12];   //keypad buffer
    char c, a;
    int i;
    ptr = kbuf;
    blanks = "      ";


    PLL_init();           //set system clock freq to 24MHz
    lcd_init();         //enable lcd
    keypad_enable();    //enable keypad
    set_lcd_addr(0x00); //display on 1st line
    i = 0;
    while(1) {
        c = getkey();     //read keypad
        a = hex2asc(c);   //convert to ascii
        kbuf[i] = a;      // and store in kbuf
        if(c<10) {        //if 0 - 9
            data8(a);      //   display on lcd
            wait_keyup();  //   wait to release key
            i++;           //increment index
        } else {
            switch(c) {
            case 0xE:   //if enter (*) key
                op1 = number(ptr);  //convert to binary
                set_lcd_addr(0x40); //display on 2nd line
                write_long_lcd(op1);
                set_lcd_addr(0x00); //clear 1st line
                type_lcd(blanks);
                wait_keyup();      //wait to release key
                i = 0;             //reset kbuf index
                set_lcd_addr(0x00); //display on 2nd line
                break;

            case 0xA:   //if key A
                op2 = number(ptr);  //convert to binary
                op1 = op1 + op2;    //compete sum
                set_lcd_addr(0x40); //display on 2nd line
                write_long_lcd(op1);
                set_lcd_addr(0x00);  //clear 1st line
                type_lcd(blanks);
                wait_keyup();        //wait to release key
                i = 0;               //reset kbuf index
                set_lcd_addr(0x00);  //display on 1st line
                break;
            case 0xF:   //if clear (#) key
                clear_lcd();  //clear lcd display
                wait_keyup(); //wait to release key
                i = 0;        //reset kbuf index
                break;
            default:
                break;
            }
        }
    }
}
예제 #3
0
파일: main.c 프로젝트: yfang1644/DSP55X
void main()
{
	int key = 0;
	int freqShift = 0;

	ICR = 0xff2e;	/* IDLE Control Register */
					/* mem port, io port and cpu idle active */

	/* Peripheral_Reset  */
	CSL_SYSCTRL_REGS->PSRCR = 0x0020;

	CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
	CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
	CSL_SYSCTRL_REGS->PRCR = 0x00bf;

/* VERY IMPORTANT !!! */
/* PPMODE1 (SPI, GPIO, UART, and I2S2):
	7 signals of the SPI module,
	6 GPIO signals(GP[17:12]),
	4 signals of the UART module,
	4 signals of the I2S2 module

   SP1MODE2 (GP[11:6]). 6 GPIO signals (GP[11:6])
   SP0MODE0 (MMC/SD0). All 6 signals of the MMC/SD0
*/
	CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
							|(CSL_SYS_EBSR_SP1MODE_MODE2 << 10)
							|(CSL_SYS_EBSR_SP0MODE_MODE0 << 8);

	asm("	bit(ST1, #ST1_INTM) = #1");
	PLL_init(80000000);				/* CPU clock = 10MHz */
	INTR_init();				/* set Interrupt vector and clean all IRs */
	EZDSP5535_GPIO_init();
	EZDSP5535_I2C_init();		/* Initialize I2C */
	aic3204_init(2, 0);		/* Initialize codec, sampling rate = 32kHz */
    DMA_audio_init(4 * FFT_L);
	EZDSP5535_I2S_init(0);		/* Initialize I2S */

	EZDSP5535_SAR_init();

	asm("	bit(ST1, #ST1_INTM) = #0");

	while(1) {
		audioProcessing(freqShift);

		key = EZDSP5535_SAR_getKey();
		if(key == SW1) {
			freqShift = 1;
			CSL_GPIO_REGS->IOOUTDATA2 &= ~0x0002;
		}
		if(key == SW2) {
			freqShift = 0;
			CSL_GPIO_REGS->IOOUTDATA2 |= 0x0002;
		}

		asm("   idle");
	}
}
예제 #4
0
void main(void) {
  PLL_init();
  lcd_init();
  SCI0_init(9600); 
  SCI1_int_init(9600); // Channel to talk to ESP8266
  motor0_init(); // These functions actually control PWM outputs
  motor1_init(); // We use them to run the RGB LED.
  motor2_init();
  RTI_init();
  SW_enable();
  
  initq();
  
  DDRH = 0; // PORTH is an input.
  result = 0;
  status = 'b';
  
  // Populate binary search tree:

  set_lcd_addr(0);
    
  send_at_command_sci1("ATE0");  // change to ATE1 for debug
  
  status = 'i';
  
  // Establish connection to server.
  
  send_at_command_sci1("AT+CWMODE=1");  // Set ESP to station mode
  
  send_at_command_sci1("AT+CIPMODE=0"); // Set ESP to normal transmission mode
  
  send_at_command_sci1("AT+CIPMUX=0");  // Set ESP to single-connection mode 
  
  send_at_command_sci1("AT+CWJAP=\"Freynet\",\"\""); // Connect to network
  
  send_at_command_sci1("AT+CIPSTART=\"TCP\",\"fpf3.net\",12345"); // connect to server

  
  while(1){
    command = '\0';   
    while(qempty());
    command = getq();
    
    switch (command) {
      case 'n':
        status = 'w';
        result = new_sequence();
        ms_delay(500); // If we finish too quickly, we open a connection the ESP thinks is already open, and it breaks.
        send_at_command_sci1("AT+CIPSTART=\"TCP\",\"fpf3.net\",12345"); // connect to server

        break;
        
    }
    outchar0(result);
  }
}
예제 #5
0
//Example 1c – 7-Segment Displays using Function calls
void main(void) {

PLL_init(); 		// set system clock frequency to 24 MHz
led_disable(); 		// disable leds

	seg7_enable(); 	// enable 7-segment displays
	seg7_on(0x55,2); 	// turn on every other segment on digit 2
	for(;;) {} /* wait forever */

}
예제 #6
0
CSL_Status pll_sample()
{
    CSL_Status status;
	volatile int i;

    status = PLL_init(&pllObj, CSL_PLL_INST_0);
    if (status != CSL_SOK)
    {
        return status;
    }

    hPll = (PLL_Handle)(&pllObj);

    PLL_reset(hPll);

    status = PLL_bypass(hPll);
    if (status != CSL_SOK)
    {
        return status;
    }

    /* Configure the PLL */
    //pConfigInfo = (PLL_Config *)&pllCfg_40MHz;
    pConfigInfo = (PLL_Config *)&pllCfg_100MHz;
    //pConfigInfo = (PLL_Config *)&pllCfg_100MHz_ExtClk12Mhz;
    //pConfigInfo = (PLL_Config *)&pllCfg_120MHz_ExtClk12Mhz;

    status = PLL_config (hPll, pConfigInfo);
    if (status != CSL_SOK)
    {
        return(status);
    }

    status = PLL_getConfig(hPll, &pllCfg1);
    if (status != CSL_SOK)
    {
        return status;
    }

    /* Wait for PLL to stabilize */
    for (i=0; i<100; i++);

    status = PLL_enable(hPll);
    if (status != CSL_SOK)
    {
        return status;
    }

    // set DSP_LDO to 1.05V
    //*(volatile ioport unsigned int *)(0x7004) |= 0x0002;

    return CSL_SOK;
}
예제 #7
0
파일: main.c 프로젝트: datsjon13/EGR280
void main(void) {
    
    PLL_init();       // set system clock frequency to 24 MHz
    ad0_enable(); // enable a/d converter 0
    ad1_enable(); // enable a/d converter 1
    led_enable();
    seg7_disable();
    servo54_init();
    lcd_init();        // enable lcd
    motor1_init(); // enable 8-bit pwm1 for computer fan
  
     
         while(1) {
            
            for (width = 3000; width < 14500; width = width + 150) {
                flame = ad0conv(3); 	// read flame sensor output on channel 3 adc0
                range = ad0conv(5); 	// read range sensor output on channel 7 adc1
                
                set_lcd_addr(0x40);
                if (range > 550) {
                    type_lcd("Flame is near!  ");
                } else {
                    type_lcd("Out of range    ");
                }
                set_servo54(width);
                ms_delay(10);
                
                if (flame > 1000) {
                    set_lcd_addr(0x00);
                    ms_delay(10);
                    type_lcd("Flame Detected! ");
                    if (range > 550) {
                          ms_delay(10);
                          //Turn the motor on for 8 seconds
                          set_lcd_addr(0x40);
                          ms_delay(10);
                          type_lcd("Flame is near!  ");
                          ms_delay(10);
                          leds_on(0b11111000);     //Motor is on
                          ms_delay(8000);
                          motor1(speed);
                          ms_delay(10);
                    }
                } else {
                    leds_on(0b11111100);     //Motor is off
                    set_lcd_addr(0x00);
                    type_lcd("No Flame        ");
                }
                ms_delay(10);
            }
    }
}
예제 #8
0
파일: main.c 프로젝트: apjansing/ECE375
void main(void) {
  /* put your own code here */
  PLL_init();        // set system clock frequency to 24 MHz 
  DDRB  = 0xff;       // Port B is output
  DDRJ  = 0xff;       // Port J is output
  DDRP  = 0xff;       // Port P is output
  PTJ = 0x00;         // enable LED
  PTP = 0x00;         // enable all 7-segment displays
  // turn on every other led and segment on 7-seg displays
  PORTB   = 0x55;        

  for(;;) {} /* wait forever */
}
예제 #9
0
void CONTROL_init(void){
    CONTROL_LOG("CONTROL_LOG: spi_init()\n");
    spi_init();
    PLL_init();
    SRC_init();
    
    PLL_set_scko1_freq(PLL_SCKO1_16MHz);
    CONTROL_set_audio_data_format(CONTROL_24_bit_I2S);
    CONTROL_set_oversampling_freq(CONTROL_OVERSAMPLING_FREQ_44_1kHz);
    CONTROL_set_attunation_level(100);
    CONTROL_set_zero_detect_mute(PCM_enabled);
    CONTROL_set_monaural_mode(PCM_stereo);
}
예제 #10
0
파일: main.c 프로젝트: eceforge/vitasign
inline void setup_handles(void){
	myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
	myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
	myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
	myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));

	myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
	myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
	myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
	mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
	myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
	myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));

}
예제 #11
0
int main(void) {
  // Select 12MHz crystal oscillator
  LPC_SC ->CLKSRCSEL = 1;

  // Init PLL 0 to 100MHz
  PLL_init(25, 2, 3);
//  PLL_init(12, 1, 18); // 16MHz
  SystemCoreClockUpdate();

  volatile uint32_t i = 1;
  while (i < (1 << 23)) { ++i; }

  LCD_init();
  LCD_function_set(BUS_WIDTH_8, LINE_COUNT_2, FONT_5_8);

  i = 1;
  while (i < (1 << 23)) { ++i; }

  LCD_write('a');
  LCD_write('b');
  LCD_write('c');
  LCD_write('d');

  char c = 'e';
  uint_fast8_t x = 0, y = 0;
  while(1) {
    LCD_write(c);
    ++c;

    ++x;
    if (x > 15) {
      x = 0;
      y ^= 1;
    }

    LCD_move_cursor(x, y);

    i = 1;
    while (i < (1 << 23)) { ++i; }
  }

  return 0;
}
예제 #12
0
파일: old.c 프로젝트: JackDoan/locolab
void main()
{
 memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
 WDOG_Handle myWDog;
 myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
 WDOG_disable(myWDog);

 CLK_Handle myClk;
 PLL_Handle myPll;
 myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
 myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));

  CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

  PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

  GPIO_Handle myGpio;
  myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));

  GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);

  GPIO_setHigh(myGpio, GPIO_Number_0);
  GPIO_setHigh(myGpio, GPIO_Number_1);
  GPIO_setHigh(myGpio, GPIO_Number_2);
  GPIO_setHigh(myGpio, GPIO_Number_3);

  while(1)
  {
    GPIO_setLow(myGpio, GPIO_Number_3);
    DELAY_US(1000000);
    GPIO_setHigh(myGpio, GPIO_Number_3);
    DELAY_US(1000000);
  }

}
예제 #13
0
파일: main.c 프로젝트: robopt/RocketMan
////////////////////////////////////////
// Initalize                          //
// Ports, Interrupts, Motor and Servo //
////////////////////////////////////////
void portInit(void){
  PLL_init(); // set system clock frequency to 24 MHz
  
  //Direction registers
  DDRH = 0x00;  // Port H is input       
  DDRB = 0x0F; // Port B starts as output
  PORTB = 0x00; // turn all LED's OFF
  DDRT = 0xFF;  // port T7 is input rest is output

  //motors
  PTT_PTT0 = 0; //default
  PTT_PTT1 = 0; //default
  PTT_PTT2 = 0; //default
  PTT_PTT3 = 0; //default
  motor0_init(); //left motor
  motor1_init(); //right motor
  
  //initialize a/d
  ad0_enable(); //enable a/d converter w/ interrupt with custom values
  RTI_init(); //turn on real time interrupt
}
예제 #14
0
파일: bsp.c 프로젝트: voileravi/zen
/*..........................................................................*/
void BSP_init(void) {
    PLL_Config pllCfg_100MHz = {
        0x8BE8U, 0x8000U, 0x0806U, 0x0000U
    };
    PLL_Obj pllObj;
    uint16_t i;

    PLL_init(&pllObj, CSL_PLL_INST_0);
    PLL_reset(&pllObj);
    PLL_config(&pllObj, &pllCfg_100MHz);

    QF_zero();                        /* clear the QF variables, see NOTE01 */

    CSL_SYSCTRL_REGS->PCGCR1 = 0U;      /* enable clocks to all peripherals */
    CSL_SYSCTRL_REGS->PCGCR2 = 0U;
    CSL_SYSCTRL_REGS->EBSR   = 0x1800U;             /* configure I/O muxing */
    CSL_SYSCTRL_REGS->PSRCR  = 0x0020U;            /* reset all peripherals */
    CSL_SYSCTRL_REGS->PRCR   = 0x00BFU;

    ULED_init();                              /* configure the User LEDs... */

    IRQ_globalDisable();
    IRQ_disableAll();                         /* disable all the interrupts */
    IRQ_clearAll();                         /* clear any pending interrupts */
    IRQ_setVecs((uint32_t)&VECSTART);               /* set the vector table */
    for (i = 1U; i < 32U; ++i) {               /* pre-fill the Vector table */
        IRQ_plug(i, &illegal_isr);                      /* with illegal ISR */
    }

    /* plug in all ISRs into the vector table...*/
//    IRQ_plug(TINT_EVENT, &TINT_isr);
//    IRQ_plug(RTC_EVENT,  &RTC_isr);
    /* ... */

    if (QS_INIT((void *)0) == 0) {    /* initialize the QS software tracing */
        Q_ERROR();
    }
    QS_OBJ_DICTIONARY(&l_TINT_isr);
}
예제 #15
0
void main(void) {

  char key;  //key pressed
  Flag *flag = createFlag();
  
  PLL_init();         //set system clock freq to 24MHz
  lcd_init();         //enable lcd display (clear display)
  keypad_enable();    //enable keypad
  led_enable();       //enable leds
  seg7_disable();     //turn off and disable seg7 display
  set_lcd_addr(0x40); //set display on 2nd line
  
 
  while(1){
     
    key = getkey();     //read keypad   
    if(flag->shift == true)  //shift key was pressed  
      shiftMode(key, flag);  //operator input keys
 
    else 
      stdMode(key, flag);   //standard input keys
      
  }  //end while(1)
}  //end main                            
CSL_Status pll_sample_freq(Uint16 freq)
{
    CSL_Status status;
	volatile int i;

    status = PLL_init(&pllObj, CSL_PLL_INST_0);
    if (status != CSL_SOK)
    {
        return status;
    }

    hPll = (PLL_Handle)(&pllObj);

    PLL_reset(hPll);

    status = PLL_bypass(hPll);
    if (status != CSL_SOK)
    {
        return status;
    }

    /* Configure the PLL */
    switch(freq){
    	case 40:
    		pConfigInfo = (PLL_Config *)&pllCfg_40MHz;
    		break;
    	case 100:
    		pConfigInfo = (PLL_Config *)&pllCfg_100MHz;
    		break;
    	case 120:
    		pConfigInfo = (PLL_Config *)&pllCfg_120MHz;
    		break;
    	default:
    		pConfigInfo = (PLL_Config *)&pllCfg_100MHz;
    }
    status = PLL_config (hPll, pConfigInfo);
    if (status != CSL_SOK)
    {
        return(status);
    }

    status = PLL_getConfig(hPll, &pllCfg1);
    if (status != CSL_SOK)
    {
        return status;
    }

    /* Wait for PLL to stabilize */
    for (i=0; i<100; i++);

    status = PLL_enable(hPll);
    if (status != CSL_SOK)
    {
        return status;
    }

    // set DSP_LDO to 1.05V
    //*(volatile ioport unsigned int *)(0x7004) |= 0x0002;

    return CSL_SOK;
}
예제 #17
0
void main(void)
{
    int i;
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // If running from flash copy RAM only functions to RAM
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

    // Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    // Register interrupt handlers in the PIE vector table
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1,
                              (intVec_t)&epwm1_timer_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_2,
                              (intVec_t)&epwm2_timer_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_3,
                              (intVec_t)&epwm3_timer_isr);

    InitEPwmTimer();    // For this example, only initialize the ePWM Timers

    // Initialize counters:
    EPwm1TimerIntCount = 0;
    EPwm2TimerIntCount = 0;
    EPwm3TimerIntCount = 0;

    // Enable CPU INT3 which is connected to EPWM1-6 INT
    CPU_enableInt(myCpu, CPU_IntNumber_3);

    // Enable EPWM INTn in the PIE: Group 3 interrupt 1-6
    PIE_enablePwmInt(myPie, PWM_Number_1);
    PIE_enablePwmInt(myPie, PWM_Number_2);
    PIE_enablePwmInt(myPie, PWM_Number_3);

    // Enable global Interrupts and higher priority real-time debug events
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);

    for(;;)
    {
        __asm(" NOP");
        for(i=1;i<=10;i++)
        {
        }
    }
}
예제 #18
0
파일: main.c 프로젝트: yfang1644/DSP55X
void main(void)
{
	Int16  *samples;
	HANDLE FHandle = Not_Open_FILE;
	Int16  *out_words = &rawOutWords[1];
	Uint8  *byte16 = &RfByte[2];	
	Int16  mlt_coefs[DCT_LENGTH];
	Int16  mag_shift[2];
	Int16  old_mag_shift[2];
	Uint16 number_of_bits_per_frame;
	Uint16 number_of_bytes_per_frame;
	Uint16 number_of_16bit_words_per_frame;
	Int16  offset;
	Int16  key;
	Uint16 chn;		// left and right channel, 0 or 1
	Int16  sent_buffer_cnt = 0;
	Uint8  *sent_buffer;
	
	ICR = 0xff2e;	/* IDLE Control Register */
					/* mem port, io port and cpu idle active */

	DSP_zero(xmt_l, DCT_LENGTH);
	DSP_zero(xmt_r, DCT_LENGTH);
	/* Peripheral_Reset  */
	CSL_SYSCTRL_REGS->PSRCR = 0x0020;

	CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
	CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
	CSL_SYSCTRL_REGS->PRCR = 0x00bf;

	CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
							| (0 << 8) | (2 << 10);//GPIO(11-6)
	asm("	bit(ST1, #ST1_INTM) = #1");

	number_of_bits_per_frame = (Uint16)(BITRATE * 20);	// BITRATE in kbps
	number_of_bytes_per_frame = (Uint16)(number_of_bits_per_frame>>3);
	number_of_16bit_words_per_frame = (Uint16)(number_of_bits_per_frame>>4);

	INTR_init();
	PLL_init();
	TIMER_init();
	EZDSP5535_GPIO_init();
	DMA_audio_init(DCT_LENGTH);

	EZDSP5535_I2C_init();		/* Initialize I2C */
	aic3204_init(6);			/* Initialize codec */
	EZDSP5535_LCD_init();
	EZDSP5535_I2S_init();		/* Initialize I2S */
	LCD_print("G722.1 Send       ", 17, 0);
	LCD_print("16kbps  ", 8, 1);
	EZDSP5535_SPI_init();
	Si446x_Init();
	EZDSP5535_SAR_init();
	DiskInit();
	FileInit();
	AddFileDriver(SDCammand, NULL);

	sam2coef_init();
	coef2sam_init();
	rawOutWords[0] = 0x6b21;
	RfByte[0] = 0x21; RfByte[1] = 0x6b;		// little-endian

	old_mag_shift[0] = 0;
	old_mag_shift[1] = 0;
	asm("	bit(ST1, #ST1_INTM) = #0");

	SpiWriteByte(CMD_GET_INT_STATUS, 0);	// clear interrupt pending
	while(1) {
		if(pingpong >= 0) {
			offset = (pingpong>>1) * DCT_LENGTH;
/*******************************************************************
 * LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT
 *******************************************************************/
			chn = LEFT;
			samples = &rcv_l[offset];		// Read frame of samples from mem.
			// Convert input samples to rmlt coefs
			mag_shift[chn] = samples_to_rmlt_coefs(samples, mlt_coefs, chn);
			// Encode the mlt coefs
			encoder(number_of_bits_per_frame, mlt_coefs, mag_shift[chn], out_words);
			byte16 = &RfByte[2];
			byte16[-2] = 0x6b; byte16[-1] = 0x20;
			DSP_word2byte(byte16, out_words, number_of_16bit_words_per_frame);
			
			// process the out_words into decoder_mlt_coefs
			decoder(out_words, mlt_coefs, &mag_shift[chn], &old_mag_shift[chn]);

			samples = &xmt_l[offset];		// Write frame of output samples
			// convert the decoder_mlt_coefs to samples
			rmlt_coefs_to_samples(mlt_coefs, samples, mag_shift[chn], chn);

/*******************************************************************
 * RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT 
 *******************************************************************/
			chn = RIGHT;
			samples = &rcv_r[offset];		// Read frame of samples from mem.
			// Convert input samples to rmlt coefs
			mag_shift[chn] = samples_to_rmlt_coefs(samples, mlt_coefs, chn);
			// Encode the mlt coefs
			encoder(number_of_bits_per_frame, mlt_coefs, mag_shift[chn], out_words);

			byte16 = &RfByte[number_of_bytes_per_frame + 4];
			byte16[-2] = 0x6b; byte16[-1] = 0x21;
			DSP_word2byte(byte16, out_words, number_of_16bit_words_per_frame);

			// process the out_words into decoder_mlt_coefs
			decoder(out_words, mlt_coefs, &mag_shift[chn], &old_mag_shift[chn]);

			samples = &xmt_r[offset];		// Write frame of output samples
			// convert the decoder_mlt_coefs to samples
			rmlt_coefs_to_samples(mlt_coefs, samples, mag_shift[chn], chn);

			if (FHandle != Not_Open_FILE)	// Write output bitstream
				FileWrite(RfByte, 2*number_of_bytes_per_frame+4, FHandle);

			pingpong = -1;
			sent_buffer = RfByte;
			sent_buffer_cnt = 0;
		}
		if(spiIsrStatus == 1) {
			bApi_Set_Send(43);
			spiIsrStatus = 0;
		}
		if(sent_buffer_cnt < 2) {
			if(gpioIsrStatus == 1) {
				SPI_sendData(sent_buffer, number_of_bytes_per_frame+2);
				sent_buffer += number_of_bytes_per_frame+2;
				sent_buffer_cnt++;
				gpioIsrStatus = 0;
				CSL_GPIO_REGS->IOINTFLG1 = 0x0800;
			}
		}

//		key = EZDSP5535_SAR_getKey();
		key = -1;
		if(key == SW1)
		if(FHandle == Not_Open_FILE)
		{
			LCD_print("RECORDING......", 15, 0);
			FHandle = FileOpen("A:\\VOICE000.TXT", FILE_FLAGS_WRITE);
		}
		if(key == SW2)
		if(FHandle != Not_Open_FILE)
		{
			LCD_print("SAVE VOICE000.DAT", 17, 0); 
			FileClose(FHandle);
			AllCacheWriteBack();
			FHandle = Not_Open_FILE;
		}
		asm("	idle");
	}
void main(void)
{
    ADC_Handle myAdc;
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myComp = COMP_init((void *)COMP1_BASE_ADDR, sizeof(COMP_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // If running from flash copy RAM only functions to RAM
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

    // For this case just init GPIO pins for ePWM1
    GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_1, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_EPWM1B);

    // Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    // Register interrupt handlers in the PIE vector table
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_2, PIE_SubGroupNumber_1,
                              (intVec_t)&epwm1_tzint_isr);

    // Enable Clock to the ADC
    CLK_enableAdcClock(myClk);
    // Comparator shares the internal BG reference of the ADC,
    // must be powered even if ADC is unused
    ADC_enableBandGap(myAdc);
    // Delay to allow BG reference to settle.
    DELAY_US(1000L);

    // Enable clock to the Comparator 1 block
    CLK_enableCompClock(myClk, CLK_CompNumber_1);
    // Power up Comparator 1 locally
    COMP_enable(myComp);
    // Connect the inverting input to pin COMP1B
    COMP_disableDac(myComp);
////////////////Uncomment following 4 lines to use DAC instead of pin COMP1B //////////////////
//    // Connect the inverting input to the internal DAC
//    COMP_enableDac(myComp);
//    // Set DAC output to midpoint
//    COMP_setDacValue(myComp, 512);
//////////////////////////////////////////////////////////////////////////////////////////////

    CLK_disableTbClockSync(myClk);

    InitEPwm1Example();

    CLK_enableTbClockSync(myClk);

    // Initialize counters
    EPwm1TZIntCount = 0;

    // Enable CPU INT3 which is connected to EPWM1-3 INT
    CPU_enableInt(myCpu, CPU_IntNumber_2);

    // Enable EPWM INTn in the PIE: Group 2 interrupt 1-3
    PIE_enablePwmTzInt(myPie, PWM_Number_1);

    // Enable global Interrupts and higher priority real-time debug events
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);

    for(;;)
    {
        __asm(" NOP");
    }
}
void main(void)
{
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    // Register interrupt handlers in the PIE vector table
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1, (intVec_t)&EPwm1_timer_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_2, (intVec_t)&EPwm2_timer_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_3, (intVec_t)&EPwm3_timer_isr);

    // Initialize the EPwm Timers used in this example
    InitEPwmTimer();

#ifdef _FLASH
    // Copy time critical code and Flash setup code to RAM
    // This includes the following ISR functions: EPwm1_timer_isr(), EPwm2_timer_isr()
    // and FLASH_setup();
    // The  RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart
    // symbols are created by the linker. Refer to the F2280270.cmd file.
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);

    // Call Flash Initialization to setup flash waitstates
    // This function must reside in RAM
    FLASH_setup(myFlash);
#endif // end #ifdef _FLASH

    // Initalize counters:
    EPwm1TimerIntCount = 0;
    EPwm2TimerIntCount = 0;
    EPwm3TimerIntCount = 0;
    LoopCount = 0;

    // Enable CPU INT3 which is connected to EPwm1-3 INT:
    CPU_enableInt(myCpu, CPU_IntNumber_3);

    // Enable EPwm INTn in the PIE: Group 3 interrupt 1-3.
    PIE_enablePwmInt(myPie, PWM_Number_1);
    PIE_enablePwmInt(myPie, PWM_Number_2);
    PIE_enablePwmInt(myPie, PWM_Number_3);

    // Enable global Interrupts and higher priority real-time debug events
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);


    // Configure GPIO so it can toggle in the idle loop
    GPIO_setMode(myGpio, GPIO_Number_34, GPIO_34_Mode_GeneralPurpose);
    GPIO_setDirection(myGpio, GPIO_Number_34, GPIO_Direction_Output);

    for(;;)
    {
        // This loop will be interrupted, so the overall
        // delay between pin toggles will be longer.
        DELAY_US(DELAY);
        LoopCount++;

        // Toggle GPIO
        GPIO_toggle(myGpio, GPIO_Number_34);
    }

}
예제 #21
0
파일: main.c 프로젝트: maxk9/etro_new
//==================================================================================
//==================================================================================
//==================================================================================
int main()
{
	bool ver = 0;
	uint8_t cnt_link = 0;
	
	PLL_init();
	GPIO_init();
	TIM1_init();
	TIM2_init();
	TIM3_init();
	UART_init();
	WDT_init();
	EEPROM_init();
	
	SysTick_Config(SystemCoreClock/800);//~10 ms
	
	
	time.t1=5;
	time.t2=5;
	time.t3=5;
	time.t4=5;
	delay_ms(100);
	
	Segment[0]=0xFF;
	Segment[1]=0xFF;
	Segment[2]=0xFF;
	Segment[3]=0xFF;
	Segment[4]=0xFF;
	Segment[5]=0xFF;
	Segment[6]=0x7F;
	ALARM_ON;
	delay_ms(100);
	ALARM_OFF;
	delay_ms(1000);
	//
	//
	
  while(1)
	{
		if( TX_st )
		{
			TX_st = 0;
			
			if( cnt_link < LINK_COUNT )
			{
				link_PKBA();
				++cnt_link;
			}
			else
			{
				PKDU.error = true;
				cnt_link = 0;
			}
		}
		
		if( RX_ok && !PKDU.error )
		{
			uint8_t cnt_byte = 0, sum = 0;
			
			while( cnt_byte < RX_FRAME_SIZE )
			{
				sum += ArrayRX_PKBA[cnt_byte];
				++cnt_byte;
			}
			sum += 0xAA;
			
			if( !sum )
			{
				StatusPKBA.reg0 = ArrayRX_PKBA[0];
				StatusPKBA.reg1 = ArrayRX_PKBA[1];
				StatusPKBA.Error = (ArrayRX_PKBA[3]<<8) | ArrayRX_PKBA[2];
				StatusPKBA.RabReg0 = ArrayRX_PKBA[4];
				StatusPKBA.UGen = (ArrayRX_PKBA[6]<<8) | ArrayRX_PKBA[5];
				StatusPKBA.IGen = (ArrayRX_PKBA[8]<<8) | ArrayRX_PKBA[7];
				StatusPKBA.DT = ArrayRX_PKBA[9];
				StatusPKBA.DM = ArrayRX_PKBA[10];
				StatusPKBA.TM = ArrayRX_PKBA[11];
				StatusPKBA.NDiz = (ArrayRX_PKBA[13]<<8) | ArrayRX_PKBA[12];
				StatusPKBA.TBapEx = ArrayRX_PKBA[14];
				StatusPKBA.TBapIn = ArrayRX_PKBA[15];
				StatusPKBA.Led1 = ArrayRX_PKBA[16];
				StatusPKBA.Led2 = ArrayRX_PKBA[17];

				if( !ver )
				{
					ver = true;
					show_ver();
					delay_ms( 1500 );
					Segment[ 0 ] = 0;
					Segment[ 1 ] = 0;
					Segment[ 2 ] = 0;
					Segment[ 3 ] = 0;
					Segment[ 4 ] = 0;
				}
			cnt_link=0;
			}
			RX_ok=0;
		}
		
		__nop();
		
		Set_Error();
		
		if(!PKDU.error)
			ShowParam();
		
		if((PKDU.StatusKN>>4)&1)
		{
			maska_err = 0;
			StatusPKBA.Error=0;
			PKDU.error=false;
			cnt_link = 0;
		}
		
		if(((PKDU.StatusKN>>5)&1) && ((PKDU.StatusKN>>6)&1))
		{
			Segment[0] = 0xFF;
			Segment[1] = 0xFF;
			Segment[2] = 0xFF;
			Segment[3] = 0xFF;
			Segment[4] = 0xFF;
			Segment[5] = 0xFF;
			Segment[6] = 0x7F;
			
			while(((PKDU.StatusKN>>5)&1)&&((PKDU.StatusKN>>6)&1))
				IWDG_ReloadCounter();
		}
		
		ControlZvonok();
		
		write_hour();
		IWDG_ReloadCounter();
	}
}
예제 #22
0
파일: main.c 프로젝트: yfang1644/DSP55X
void main(void)
{
	Int16  temp_cnt;

	ICR = 0xff2e;	/* IDLE Control Register */
					/* mem port, io port and cpu idle active */

	/* Peripheral_Reset  */
	CSL_SYSCTRL_REGS->PSRCR = 0x0020;

	CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
	CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
	CSL_SYSCTRL_REGS->PRCR = 0x00bf;

/* VERY IMPORTANT !!! */
/* PPMODE1 (SPI, GPIO, UART, and I2S2):
    7 signals of the SPI module,
    6 GPIO signals(GP[17:12]),
    4 signals of the UART module,
    4 signals of the I2S2 module

   SP1MODE2 (GP[11:6]). 6 GPIO signals (GP[11:6])
   SP0MODE0 (MMC/SD0). All 6 signals of the MMC/SD0
*/
	CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
							|(CSL_SYS_EBSR_SP1MODE_MODE2 << 10)
							|(CSL_SYS_EBSR_SP0MODE_MODE0 << 8);

	asm("	bit(ST1, #ST1_INTM) = #1");

	INTR_init();
	PLL_init(3658);		// system clock set to 120MHz
	TIMER_init();
	EZDSP5535_GPIO_init();
	EZDSP5535_I2C_init();		/* Initialize I2C */

	Audio_init(7);				/* Initialise to bandwidth=7kHz */

	EZDSP5535_LCD_init();
	LCD_print("G722.1 Receiver  ", 17, 0);
	LCD_print("16kbps  ", 8, 1);
	EZDSP5535_SPI_init();
	Si446x_Init();

	EZDSP5535_SAR_init();
	DiskInit();
	FileInit();

	AddFileDriver(SDCammand, NULL);

	asm("	bit(ST1, #ST1_INTM) = #0");

	bApi_Set_Receive();
	while(1) {
		if(gpioIsrStatus == 1) {
			temp_cnt = SPI_recvData(spibuffer);

			gpioIsrStatus = 0;
			CSL_GPIO_REGS->IOINTFLG1 = 0x0800;
		}

		if(spiIsrStatus == 1) {
//			SpiWriteByte(CMD_FIFO_INFO, 0);
			SpiWriteByte(CMD_GET_INT_STATUS, 0);
			bApi_Set_Receive();
			if(audioProcessing())	continue;

			spiIsrStatus = 0;
		}

		fileProcessing();

		asm("	idle");
	}

//	RemoveFileDriver(SDCammand);
}
예제 #23
0
int pll_frequency_setup(unsigned int frequency)
{
    CSL_Status status;

    status = PLL_init(&pllObj, CSL_PLL_INST_0);
    if(CSL_SOK != status)
    {
       printf("PLL init failed \n");
       return (status);
    }

	hPll = (PLL_Handle)(&pllObj);

	PLL_reset(hPll);

   /* Configure the PLL for different frequencies */

   if ( frequency == 1)
    {
      pConfigInfo = &pllCfg_1MHz;
      printf("\nLL frequency 1 MHz\n");
    }
   else if ( frequency == 2)
    {
      pConfigInfo = &pllCfg_2MHz;
      printf("\nPLL frequency 2 MHz\n");     
    } 
   else if ( frequency == 12)
    {
      pConfigInfo = &pllCfg_12MHz; 
      printf("\nPLL frequency 12 MHz\n");        
    }
   else if ( frequency == 40)
    {
      pConfigInfo = &pllCfg_40MHz;
      printf("\nPLL frequency 40 MHz\n");     
    } 
   else if ( frequency == 60)
    {
      pConfigInfo = &pllCfg_60MHz; 
      printf("\nPLL frequency 60 MHz\n");        
    }
   else if ( frequency == 75)
    {
      pConfigInfo = &pllCfg_75MHz;
      printf("\nPLL frequency 75 MHz\n");     
    } 
   else if ( frequency == 98)
    {
      pConfigInfo = &pllCfg_98MHz; 
      printf("\nPLL frequency 98 MHz\n");        
    }  
   else if ( frequency == 120)
   {
      pConfigInfo = &pllCfg_120MHz;
      printf("\nPLL frequency 120 MHz\n");        
   }
   else 
   {
      pConfigInfo = &pllCfg_100MHz;
      printf("\nPLL frequency 100 MHz\n");        
   }

   status = PLL_config (hPll, pConfigInfo);
   if(CSL_SOK != status)
   {
       printf("PLL config failed\n");
       return(status);
   }

	status = PLL_getConfig(hPll, &pllCfg1);
    if(status != CSL_SOK)
	{
	    printf("TEST FAILED: PLL get config... Failed.\n");
		printf ("Reason: PLL_getConfig failed. [status = 0x%x].\n", status);
		return(status);
	}

    printf("REGISTER --- CONFIG VALUES\n");

    printf("PLL_CNTRL1   %04x --- %04x\n",pllCfg1.PLLCNTL1,hPll->pllConfig->PLLCNTL1);
    printf("PLL_CNTRL2   %04x --- %04x Test Lock Mon will get set after PLL is up\n",
                                pllCfg1.PLLCNTL2,hPll->pllConfig->PLLCNTL2);
    printf("PLL_CNTRL3   %04x --- %04x\n",pllCfg1.PLLINCNTL,hPll->pllConfig->PLLINCNTL);
    printf("PLL_CNTRL4   %04x --- %04x\n",pllCfg1.PLLOUTCNTL,hPll->pllConfig->PLLOUTCNTL);

   status = PLL_bypass(hPll);
   if(CSL_SOK != status)
   {
       printf("PLL bypass failed:%d\n",CSL_ESYS_BADHANDLE);
       return(status);
   }

   status = PLL_enable(hPll);
   if(CSL_SOK != status)
   {
       printf("PLL enable failed:%d\n",CSL_ESYS_BADHANDLE);
       return(status);
   }

   return(CSL_TEST_PASSED);
}
void main(void)
{
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    myPwm4 = PWM_init((void *)PWM_ePWM4_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2
    PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // If running from flash copy RAM only functions to RAM
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the f2802x_SysCtrl.c file.
//   InitSysCtrl();

// Step 2. Initialize GPIO:
// This example function is found in the f2802x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio();  // Skipped for this example
//   InitEPwmGpio();

// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
//   DINT;

// Initialize the PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the f2802x_PieCtrl.c file.
//   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
//   IER = 0x0000;
//   IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in f2802x_DefaultIsr.c.
// This function is found in f2802x_PieVect.c.
//   InitPieVectTable();

// For this case just init GPIO pins for EPwm1, EPwm2, EPwm3, EPwm4
    GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_1, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_EPWM1B);

    GPIO_setPullUp(myGpio, GPIO_Number_2, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_3, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_EPWM2A);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_EPWM2B);

    GPIO_setPullUp(myGpio, GPIO_Number_4, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_5, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_4, GPIO_4_Mode_EPWM3A);
    GPIO_setMode(myGpio, GPIO_Number_5, GPIO_5_Mode_EPWM3B);

    GPIO_setPullUp(myGpio, GPIO_Number_6, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_7, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_EPWM4A);
    GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_EPWM4B);

// Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

// Step 4. Initialize the Device Peripherals:
    CLK_enablePwmClock(myClk, PWM_Number_1);
    CLK_enablePwmClock(myClk, PWM_Number_2);
    CLK_enablePwmClock(myClk, PWM_Number_3);
    CLK_enablePwmClock(myClk, PWM_Number_4);
    CLK_enableHrPwmClock(myClk);

// For this example, only initialize the ePWM
// Step 5. User specific code, enable interrupts:

   // Calling SFO() updates the HRMSTEP register with calibrated MEP_ScaleFactor.
   // HRMSTEP must be populated with a scale factor value prior to enabling
   // high resolution period control.

    status = SFO_INCOMPLETE;
    while  (status== SFO_INCOMPLETE) // Call until complete
    {
        status = SFO();
        if (status == SFO_ERROR)
        {
            error();   // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
        }              // exceeds maximum of 255.
    }

// Some useful PWM period vs Frequency values
//  TBCLK = 60 MHz
//===================
//  Period   Freq
//  1000     30 KHz
//  800    37.5 KHz
//  600      50 KHz
//  500      60 KHz
//  250     120 KHz
//  200     150 KHz
//  100     300 KHz
//  50      600 KHz
//  30        1 MHz
//  25      1.2 MHz
//  20      1.5 MHz
//  12      2.5 MHz
//  10        3 MHz
//  9       3.3 MHz
//  8       3.8 MHz
//  7       4.3 MHz
//  6       5.0 MHz
//  5       6.0 MHz

//====================================================================
// ePWM and HRPWM register initialization
//====================================================================
    Period = 500;
    PeriodFine=0xFFBF;

    CLK_disableTbClockSync(myClk);

    HRPWM_Config(myPwm1, Period, 1);
    HRPWM_Config(myPwm2, Period, 0);
    HRPWM_Config(myPwm3, Period, 0);
    HRPWM_Config(myPwm4, Period, 0);

    CLK_enableTbClockSync(myClk);

   // Software Control variables
   Increment_Freq = 1;
   Increment_Freq_Fine = 1;
   IsrTicker = 0;
   UpdatePeriod = 0;
   UpdatePeriodFine = 0;

   // User control variables:
   UpdateCoarse = 0;
   UpdateFine = 1;

   // Reassign ISRs.
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1,
                              (intVec_t)&MainISR);

// Enable PIE group 3 interrupt 1 for EPWM1_INT
    PIE_enableInt(myPie, PIE_GroupNumber_3, PIE_InterruptSource_EPWM1);

// Enable CNT_zero interrupt using EPWM1 Time-base
    PWM_setIntMode(myPwm1, PWM_IntMode_CounterEqualZero);   // Select INT on Zero event
    PWM_enableInt(myPwm1);                                  // Enable INT
    PWM_setIntPeriod(myPwm1, PWM_IntPeriod_FirstEvent);     // Generate INT on 3rd event
    PWM_clearIntFlag(myPwm1);

// Enable CPU INT3 for EPWM1_INT:
    CPU_enableInt(myCpu, CPU_IntNumber_3);

// Enable global Interrupts and higher priority real-time debug events:
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);

   PWM_forceSync(myPwm1); // Synchronize high resolution phase to start HR period

   for(;;)
   {
        // The below code controls coarse edge movement
        if(UpdateCoarse==1)
        {
            if(Increment_Freq==1)           //Increase frequency to 600 kHz
                Period= Period - 1;
            else
                Period= Period + 1;         //Decrease frequency to 300 kHz

            if(Period<100 && Increment_Freq==1)
                Increment_Freq=0;
            else if(Period>500 && Increment_Freq==0)
                Increment_Freq=1;

            UpdatePeriod=1;
        }

        // The below code controls high-resolution fine edge movement
        if(UpdateFine==1)
        {
            if(Increment_Freq_Fine==1)    // Increase high-resolution frequency
                PeriodFine=PeriodFine-1;
            else
                PeriodFine=PeriodFine+1; // Decrement high-resolution frequency

            if(PeriodFine<=0x3333 && Increment_Freq_Fine==1)
                Increment_Freq_Fine=0;
            else if(PeriodFine>= 0xFFBF && Increment_Freq_Fine==0)
                Increment_Freq_Fine=1;

            UpdatePeriodFine=1;
        }

        // Call the scale factor optimizer lib function SFO()
        // periodically to track for any change due to temp/voltage.
        // This function generates MEP_ScaleFactor by running the
        // MEP calibration module in the HRPWM logic. This scale
        // factor can be used for all HRPWM channels. HRMSTEP
        // register is automatically updated by the SFO function.

        status = SFO(); // in background, MEP calibration module continuously updates MEP_ScaleFactor
        if (status == SFO_ERROR)
        {
            error();   // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
        }              // exceeds maximum of 255.
    }
}// end main
예제 #25
0
void main(void)
{
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    myPwm4 = PWM_init((void *)PWM_ePWM4_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2
    PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // If running from flash copy RAM only functions to RAM
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the f2802x_SysCtrl.c file.
//   InitSysCtrl();

// Step 2. Initialize GPIO:
// This example function is found in the f2802x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio();  // Skipped for this example
// For this case, just init GPIO for EPwm1-EPwm4

// For this case just init GPIO pins for EPwm1, EPwm2, EPwm3, EPwm4
// These functions are in the f2802x_EPwm.c file
//   InitEPwm1Gpio();
//   InitEPwm2Gpio();
//   InitEPwm3Gpio();
//   InitEPwm4Gpio();

// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
//   DINT;

// Initialize the PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the f2802x_PieCtrl.c file.
//   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
//   IER = 0x0000;
//   IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in f2802x_DefaultIsr.c.
// This function is found in f2802x_PieVect.c.
//   InitPieVectTable();

// For this case just init GPIO pins for EPwm1, EPwm2, EPwm3, EPwm4
    GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_1, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_EPWM1B);

    GPIO_setPullUp(myGpio, GPIO_Number_2, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_3, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_EPWM2A);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_EPWM2B);

    GPIO_setPullUp(myGpio, GPIO_Number_4, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_5, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_4, GPIO_4_Mode_EPWM3A);
    GPIO_setMode(myGpio, GPIO_Number_5, GPIO_5_Mode_EPWM3B);

    GPIO_setPullUp(myGpio, GPIO_Number_6, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_7, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_EPWM4A);
    GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_EPWM4B);

// Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    CLK_enablePwmClock(myClk, PWM_Number_1);
    CLK_enablePwmClock(myClk, PWM_Number_2);
    CLK_enablePwmClock(myClk, PWM_Number_3);
    CLK_enablePwmClock(myClk, PWM_Number_4);

// For this example, only initialize the EPwm
// Step 4. User specific code, enable interrupts:
   update =1;
   DutyFine =0;

   CLK_disableTbClockSync(myClk);

// Some useful Period vs Frequency values
//  SYSCLKOUT =     60 MHz       40 MHz
//  --------------------------------------
//    Period            Frequency    Frequency
//    1000               60 kHz       40 kHz
//    800                75 kHz       50 kHz
//    600                100 kHz      67 kHz
//    500                120 kHz      80 kHz
//    250                240 kHz      160 kHz
//    200                300 kHz      200 kHz
//    100                600 kHz      400 kHz
//    50                 1.2 Mhz      800 kHz
//    25                 2.4 Mhz      1.6 MHz
//    20                 3.0 Mhz      2.0 MHz
//    12                 5.0 MHz      3.3 MHz
//    10                 6.0 MHz      4.0 MHz
//    9                  6.7 MHz      4.4 MHz
//    8                  7.5 MHz      5.0 MHz
//    7                  8.6 MHz      5.7 MHz
//    6                  10.0 MHz     6.6 MHz
//    5                  12.0 MHz     8.0 MHz

//====================================================================
// EPwm and HRPWM register initialization
//====================================================================
   HRPWM1_Config(10);         // EPwm1 target, Period = 10
   HRPWM2_Config(20);         // EPwm2 target, Period = 20
   HRPWM3_Config(10);         // EPwm3 target, Period = 10
   HRPWM4_Config(20);         // EPwm4 target, Period = 20

   CLK_enableTbClockSync(myClk);

   while (update ==1)
   {
        PWM_setCmpAHr(myPwm1, DutyFine << 8);
        PWM_setCmpAHr(myPwm2, DutyFine << 8);
        PWM_setCmpAHr(myPwm3, DutyFine << 8);
        PWM_setCmpAHr(myPwm4, DutyFine << 8);
   }
}
예제 #26
0
void main(void)
{
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    // Initialize all the handles needed for this application
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    myPwm4 = PWM_init((void *)PWM_ePWM4_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    CLK_disableAdcClock(myClk);

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    // Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2
    PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

    // Disable the PIE and all interrupts
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    // If running from flash copy RAM only functions to RAM
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the f2802x_SysCtrl.c file.
//   InitSysCtrl();

// Step 2. Initialize GPIO:
// This example function is found in the f2802x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio();  // Skipped for this example
//   InitEPwmGpio();

// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
//   DINT;

// Initialize the PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the f2802x_PieCtrl.c file.
//   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
//   IER = 0x0000;
//   IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in f2802x_DefaultIsr.c.
// This function is found in f2802x_PieVect.c.
//   InitPieVectTable();

// For this case just init GPIO pins for EPwm1, EPwm2, EPwm3, EPwm4
    GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_1, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_EPWM1B);

    GPIO_setPullUp(myGpio, GPIO_Number_2, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_3, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_EPWM2A);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_EPWM2B);

    GPIO_setPullUp(myGpio, GPIO_Number_4, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_5, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_4, GPIO_4_Mode_EPWM3A);
    GPIO_setMode(myGpio, GPIO_Number_5, GPIO_5_Mode_EPWM3B);

    GPIO_setPullUp(myGpio, GPIO_Number_6, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_7, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_EPWM4A);
    GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_EPWM4B);

// Setup a debug vector table and enable the PIE
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    CLK_enablePwmClock(myClk, PWM_Number_1);
    CLK_enablePwmClock(myClk, PWM_Number_2);
    CLK_enablePwmClock(myClk, PWM_Number_3);
    CLK_enablePwmClock(myClk, PWM_Number_4);
    CLK_enableHrPwmClock(myClk);

// For this example, only initialize the ePWM
// Step 4. User specific code, enable interrupts:
    UpdateFine = 1;
    PeriodFine = 0;
    status = SFO_INCOMPLETE;

   // Calling SFO() updates the HRMSTEP register with calibrated MEP_ScaleFactor.
   // HRMSTEP must be populated with a scale factor value prior to enabling
   // high resolution period control.

    while  (status== SFO_INCOMPLETE) // Call until complete
    {
        status = SFO();
        if (status == SFO_ERROR)
        {
            error();    // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
        }               // exceeds maximum of 255.
    }

// Some useful Period vs Frequency values
//  SYSCLKOUT =     60 MHz       40 MHz
//  --------------------------------------
//  Period          Frequency    Frequency
//  1000            60 kHz       40 kHz
//  800             75 kHz       50 kHz
//  600             100 kHz      67 kHz
//  500             120 kHz      80 kHz
//  250             240 kHz      160 kHz
//  200             300 kHz      200 kHz
//  100             600 kHz      400 kHz
//  50              1.2 Mhz      800 kHz
//  25              2.4 Mhz      1.6 MHz
//  20              3.0 Mhz      2.0 MHz
//  12              5.0 MHz      3.3 MHz
//  10              6.0 MHz      4.0 MHz
//  9               6.7 MHz      4.4 MHz
//  8               7.5 MHz      5.0 MHz
//  7               8.6 MHz      5.7 MHz
//  6               10.0 MHz     6.6 MHz
//  5               12.0 MHz     8.0 MHz

//====================================================================
// ePWM and HRPWM register initialization
//====================================================================

    CLK_disableTbClockSync(myClk);

    HRPWM_Config(myPwm1, 30);        // ePWMx target
    HRPWM_Config(myPwm2, 30);        // ePWMx target
    HRPWM_Config(myPwm3, 30);        // ePWMx target
    HRPWM_Config(myPwm4, 30);        // ePWMx target

    CLK_enableTbClockSync(myClk);


    PWM_forceSync(myPwm1);
    PWM_forceSync(myPwm2);
    PWM_forceSync(myPwm3);
    PWM_forceSync(myPwm4);

   for(;;)
   {
        // Sweep PeriodFine as a Q16 number from 0.2 - 0.999
        for(PeriodFine = 0x3333; PeriodFine < 0xFFBF; PeriodFine++)
        {
            if(UpdateFine)
            {
            /*
            // Because auto-conversion is enabled, the desired
            // fractional period must be written directly to the
            // TBPRDHR (or TBPRDHRM) register in Q16 format
            // (lower 8-bits are ignored)

            EPwm1Regs.TBPRDHR = PeriodFine;

            // The hardware will automatically scale
            // the fractional period by the MEP_ScaleFactor
            // in the HRMSTEP register (which is updated
            // by the SFO calibration software).

            // Hardware conversion:
            // MEP delay movement = ((TBPRDHR(15:0) >> 8) *  HRMSTEP(7:0) + 0x80) >> 8

            */

//                for(i=1;i<PWM_CH;i++)
//                {
//                    (*ePWM[i]).TBPRDHR = PeriodFine; //In Q16 format
//                }
                PWM_setPeriodHr(myPwm1, PeriodFine);
                PWM_setPeriodHr(myPwm2, PeriodFine);
                PWM_setPeriodHr(myPwm3, PeriodFine);
                PWM_setPeriodHr(myPwm4, PeriodFine);

            }
            else
            {
            // No high-resolution movement on TBPRDHR.

//                for(i=1;i<PWM_CH;i++)
//                {
//                 (*ePWM[i]).TBPRDHR = 0;
//                }
                PWM_setPeriodHr(myPwm1, 0);
                PWM_setPeriodHr(myPwm2, 0);
                PWM_setPeriodHr(myPwm3, 0);
                PWM_setPeriodHr(myPwm4, 0);
            }

            // Call the scale factor optimizer lib function SFO()
            // periodically to track for any change due to temp/voltage.
            // This function generates MEP_ScaleFactor by running the
            // MEP calibration module in the HRPWM logic. This scale
            // factor can be used for all HRPWM channels. HRMSTEP
            // register is automatically updated by the SFO function.

            status = SFO(); // in background, MEP calibration module continuously updates MEP_ScaleFactor
            if (status == SFO_ERROR) {
                error();   // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
            }              // exceeds maximum of 255.

        } // end PeriodFine for loop

    }     // end infinite for loop

}         // end main
예제 #27
0
파일: main.c 프로젝트: yfang1644/DSP55X
void main(void)
{
    ICR = 0xff2e;	/* IDLE Control Register */
    /* mem port, io port and cpu idle active */

    /* Peripheral_Reset  */
    CSL_SYSCTRL_REGS->PSRCR = 0x0020;
    CSL_SYSCTRL_REGS->PRCR = 0x00bf;
    EZDSP5535_waitusec(5);
    /* Peripheral Clock Gating Configuration Register1
       0: active, 1: disable
       SYSCLKDIS I2S2 TMR2 TMR1   X    TMR0 I2S1 I2S0
          MMCSD1 I2C  X    MMCSD0 DMA0 UART SPI  I2S3 */
    CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
    /* Peripheral Clock Gating Configuration Register2
      X X X X X X X X X X ANAREG DMA3 DMA2 DMA1 USB SAR LCD */
    CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;

    /* VERY IMPORTANT !!! */
    /* PPMODE1 (SPI, GPIO, UART, and I2S2):
    	7 signals of the SPI module,
    	6 GPIO signals(GP[17:12]),
    	4 signals of the UART module,
    	4 signals of the I2S2 module

       SP1MODE2 (GP[11:6]). 6 GPIO signals (GP[11:6])
       SP0MODE0 (MMC/SD0). All 6 signals of the MMC/SD0
    */
    CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
                             |(CSL_SYS_EBSR_SP1MODE_MODE2 << 10)
                             |(CSL_SYS_EBSR_SP0MODE_MODE0 << 8);

    asm("	bit(ST1, #ST1_INTM) = #1");

    PLL_init(200000000);			/* 100MHz */

    INTR_init();				/* set Interrupt vector and clean all IRs */
    TIMER_init();				/* Timer interrupt */
    EZDSP5535_GPIO_init();		/* Enable GPIO LED */
//	RTC_reset();
    EZDSP5535_I2C_init();		/* Initialize I2C */
    EZDSP5535_UART_init();		/* Initialize UART */
    Audio_init(7);				/* Initialise set to BandWidth=7kHz */
    File_init();
    EZDSP5535_LCD_init();		/* Initialise LCD */
    LCD_print("G722.1 recorder", 0);
    LCD_print("start", 1);
    SCHEDULE_init();
    BoardUSB_init();
    asm("	bit(ST1, #ST1_INTM) = #0");

    while(1) {
        while(taskList) {
            audioProcessing();
            uartProcessing();
            alarmProcessing();
            usbProcessing();
        }
        asm("	idle");
    }
}