//*****************************************************************************
//
// Delay for the specified number of seconds.  Depending upon the current
// SysTick value, the delay will be between N-1 and N seconds (i.e. N-1 full
// seconds are guaranteed, along with the remainder of the current second).
//
//*****************************************************************************
void
Delay(uint32_t ui32Seconds)
{
    uint8_t ui8Loop;

    //
    // Loop while there are more seconds to wait.
    //
    while(ui32Seconds--)
    {
        for(ui8Loop = 0; ui8Loop < 100; ui8Loop++)
        {
            //
            // Wait until the SysTick value is less than 1000.
            //
            while(ROM_SysTickValueGet() > 1000)
            {
            }

            //
            // Wait until the SysTick value is greater than 1000.
            //
            while(ROM_SysTickValueGet() < 1000)
            {
            }
        }
    }
}
Exemple #2
0
//*****************************************************************************
//
// This function is called to handle the GPIO edge interrupt from the
// quadrature encoder.
//
//*****************************************************************************
void
EncoderIntHandler(void)
{
    unsigned long ulNow;

    //
    // Save the time.
    //
    ulNow = ROM_SysTickValueGet();

    //
    // Clear the encoder interrupt.
    //
    ROM_GPIOPinIntClear(QEI_PHA_PORT, QEI_PHA_PIN);

    //
    // Determine the number of system clocks between the previous edge and this
    // edge.
    //
    if(g_ulEncoderPrevious > ulNow)
    {
        g_ulEncoderClocks = g_ulEncoderPrevious - ulNow;
    }
    else
    {
        g_ulEncoderClocks = (16777216 - ulNow) + g_ulEncoderPrevious;
    }

    //
    // Save the time of the current edge as the time of the previous edge.
    //
    g_ulEncoderPrevious = ulNow;

    //
    // Indicate that an edge has been seen.
    //
    HWREGBITH(&g_usEncoderFlags, ENCODER_FLAG_EDGE) = 1;

    //
    // If the previous edge time was valid, then indicate that the time between
    // edges is also now valid.
    //
    if(HWREGBITH(&g_usEncoderFlags, ENCODER_FLAG_PREVIOUS) == 1)
    {
        HWREGBITH(&g_usEncoderFlags, ENCODER_FLAG_VALID) = 1;
    }

    //
    // Indicate that the previous edge time is valid.
    //
    HWREGBITH(&g_usEncoderFlags, ENCODER_FLAG_PREVIOUS) = 1;
}
//*****************************************************************************
//
// Delay for the specified number of seconds.  Depending upon the current
// SysTick value, the delay will be between N-1 and N seconds (i.e. N-1 full
// seconds are guaranteed, along with the remainder of the current second).
//
//*****************************************************************************
void
Delay(unsigned long ulSeconds)
{
    //
    // Loop while there are more seconds to wait.
    //
    while(ulSeconds--)
    {
        //
        // Wait until the SysTick value is less than 1000.
        //
        while(ROM_SysTickValueGet() > 1000)
        {
        }

        //
        // Wait until the SysTick value is greater than 1000.
        //
        while(ROM_SysTickValueGet() < 1000)
        {
        }
    }
}
Exemple #4
0
int main_simple(void)
{

    static uint32_t g_ui32SrcBuf[MEM_BUFFER_SIZE];
    static uint32_t g_ui32DstBuf[MEM_BUFFER_SIZE];

    /* Set up clock for 120MHz */
    MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                            SYSCTL_OSC_MAIN |
                            SYSCTL_USE_PLL |
                            SYSCTL_CFG_VCO_480), 120000000);

    /* Set up SysTick timer */
    ROM_SysTickPeriodSet(0xffffffff);
    ROM_SysTickEnable();

    /* Enable interrupts */
    ROM_IntMasterEnable();

    init_dma_memcpy(UDMA_CHANNEL_SW);

    { /* Scope out the counter */
        uint_fast16_t ui16Idx;

        /* Fill source buffer with varying numbers */
        for(ui16Idx = 0; ui16Idx < MEM_BUFFER_SIZE; ui16Idx++)
        {
            g_ui32SrcBuf[ui16Idx] = ui16Idx;
        }
    }

    void *cbfn_ptr[2] = {&set_udma_txfer_done, NULL};

    volatile unsigned int t0 = (ROM_SysTickValueGet());

    dma_memcpy(
        g_ui32DstBuf,
        g_ui32SrcBuf,
        MEM_BUFFER_SIZE,
        UDMA_CHANNEL_SW,
        cbfn_ptr[0]
    );

    /* Wait for udma txfer to complete */
    while (!udma_txfer_done);

    volatile unsigned int t1 = (ROM_SysTickValueGet());

    memcpy(g_ui32DstBuf, g_ui32SrcBuf, MEM_BUFFER_SIZE);
    volatile unsigned int t2 = (ROM_SysTickValueGet());

    t2 = t1 - t2; /* Calc time taken for memcpy */
    t1 = t0 - t1; /* Calc time taken for dma_memcpy */

    volatile uint32_t count_past_dma = 0;

    /* Wait around compare txfer times */
    while (1){
        count_past_dma++;
    }

    return 0;

}
Exemple #5
0
//*****************************************************************************
//
// This function is called to handle the GPIO edge interrupt from the
// quadrature encoder.
//
//*****************************************************************************
void
QEI1IntHandler(void)
{
    unsigned long ulNow;

    //
    // Save the time.
    //
     ulNow = ROM_SysTickValueGet(); 

    //
    // Clear the encoder interrupt.
    //
    GPIOPinIntClear(QEI_ROLL_PHA_PORT, QEI_ROLL_PHA_PIN);

	ulstatus1 = QEIIntStatus(QEI1_BASE,false); 
	if (  (ulstatus1 & QEI_INTDIR) == QEI_INTDIR) 
	{ 
	  // 
	  // clear	Interrupt Bit	 
	   QEIIntClear(QEI1_BASE, QEI_INTDIR); 
	  // 
	  //code for Direction change 
	  //.............. 
	} 
	if (  (ulstatus1 & QEI_INTINDEX) == QEI_INTINDEX) 
	{ 
	  // 
	  // clear	Interrupt Bit	 
	   QEIIntClear(QEI1_BASE, QEI_INTINDEX); 
	  // 
	  //code for Index change 
	  //.............. 
	}		
	if (  (ulstatus1 & QEI_INTERROR) == QEI_INTERROR) 
	{ 
	  //	 
	  // clear	Interrupt Bit	 
		QEIIntClear(QEI1_BASE, QEI_INTERROR); 
	  // 
	  //code for Phase ERROR 
	  //.............. 
	} 

    //
    // Determine the number of system clocks between the previous edge and this
    // edge.
    //
    if(g_ulEncoder1Previous > ulNow)
    {
        g_ulEncoder1Clocks = g_ulEncoder1Previous - ulNow;
    }
    else
    {
        g_ulEncoder1Clocks = (SYSCLK_80MHZ - ulNow) + g_ulEncoder1Previous;		
		
    }

    //
    // Save the time of the current edge as the time of the previous edge.
    //
    g_ulEncoder1Previous = ulNow;

    //
    // Indicate that an edge has been seen.
    //
    HWREGBITH(&g_usEncoder1Flags, ENCODER_FLAG_EDGE) = 1;

    //
    // If the previous edge time was valid, then indicate that the time between
    // edges is also now valid.
    //
    if(HWREGBITH(&g_usEncoder1Flags, ENCODER_FLAG_PREVIOUS) == 1)
    {
        HWREGBITH(&g_usEncoder1Flags, ENCODER_FLAG_VALID) = 1;
    }

    //
    // Indicate that the previous edge time is valid.
    //
    HWREGBITH(&g_usEncoder1Flags, ENCODER_FLAG_PREVIOUS) = 1;
}