Generowanie nanosekundowego opóźnienia w C na STM32

Question

Używam kontrolera STM32F2 i współpracuję z wyświetlaczem LCD ST7036 przez 8-bitowy interfejs równoległy.

Arkusz danych mówi, że powinno być 20 nano sekundowe opóźnienie między zatrzymaniem adresu i czasem konfiguracji.

Jak wygenerować opóźnienie o 20 nanosekund w C?

Answer 1

Pierwsza specyfikacja, którą znalazłem w Stm32f2, zakłada częstotliwość taktowania 120 MHz. To około 8ns na cykl zegara. Będziesz potrzebował około trzech instrukcji jednego cyklu pomiędzy kolejnymi operacjami zapisu lub odczytu/zapisu. W C, prawdopodobnie będzie to robił a++; (jeśli a znajduje się w stosie).

Answer 2

Użyj stopwatch_delay(ticks) poniżej, aby wykonać opóźnienia. Wykorzystuje rejestr DWT_CYCCNT STM32, który jest specjalnie zaprojektowany do liczenia rzeczywistych tyknięć zegara, zlokalizowanych pod adresem 0xE0001004.

Aby zweryfikować dokładność opóźnienia (patrz main), można wywołać STOPWATCH_START uruchom stopwatch_delay(ticks), a następnie zadzwonić STOPWATCH_STOP i zweryfikować z CalcNanosecondsFromStopwatch(m_nStart, m_nStop). Dostosuj ticks w razie potrzeby.

uint32_t m_nStart;    //DEBUG Stopwatch start cycle counter value 
uint32_t m_nStop;    //DEBUG Stopwatch stop cycle counter value 

#define DEMCR_TRCENA 0x01000000 

/* Core Debug registers */ 
#define DEMCR   (*((volatile uint32_t *)0xE000EDFC)) 
#define DWT_CTRL  (*(volatile uint32_t *)0xe0001000) 
#define CYCCNTENA  (1<<0) 
#define DWT_CYCCNT  ((volatile uint32_t *)0xE0001004) 
#define CPU_CYCLES  *DWT_CYCCNT 

#define STOPWATCH_START { m_nStart = *((volatile unsigned int *)0xE0001004);} 
#define STOPWATCH_STOP { m_nStop = *((volatile unsigned int *)0xE0001004);} 


static inline void stopwatch_reset(void) 
{ 
    /* Enable DWT */ 
    DEMCR |= DEMCR_TRCENA; 
    *DWT_CYCCNT = 0;    
    /* Enable CPU cycle counter */ 
    DWT_CTRL |= CYCCNTENA; 
} 

static inline uint32_t stopwatch_getticks() 
{ 
    return CPU_CYCLES; 
} 

static inline void stopwatch_delay(uint32_t ticks) 
{ 
    uint32_t end_ticks = ticks + stopwatch_getticks(); 
    while(1) 
    { 
      if (stopwatch_getticks() >= end_ticks) 
        break; 
    } 
} 

uint32_t CalcNanosecondsFromStopwatch(uint32_t nStart, uint32_t nStop) 
{ 
    uint32_t nDiffTicks; 
    uint32_t nClkTicksPerMicrosec; 

    nDiffTicks = nStop - nStart; 
    nDiffTicks *= 1000;        // Scale diff by 1000. 
    nClkTicksPerMicrosec = SystemCoreClock/1000000; // Convert (clkTicks/sec) to (clkTicks/microsec), SystemCoreClock = 168000000 

    return nDiffTicks/nClkTicksPerMicrosec;   // nanosec = (ticks * 1000)/(clkTicks/microsec) 
} 

void main(void) 
{ 
    int timeDiff = 0; 
    stopwatch_reset(); 

    STOPWATCH_START; 
    run_my_function(); 
    STOPWATCH_STOP; 

    timeDiff = CalcNanosecondsFromStopwatch(m_nStart, m_nStop); 
    printf("My function took %d nanoseconds\n", timeDiff); 
} 

Answer 3

Powinieneś zajrzeć do urządzenia peryferyjnego FSMC dostępnego w twoim chipie. Chociaż konfiguracja może być skomplikowana, szczególnie jeśli nie upuszczasz części pamięci, dla której został zaprojektowany, może się okazać, że Twoje urządzenie z interfejsem równoległym jest dość dobrze odwzorowane w jednym z trybów interfejsu pamięci.

Te zewnętrzne kontrolery pamięci muszą mieć kilka konfigurowalnych opcji synchronizacji, aby obsłużyć zakres różnych układów pamięci, dzięki czemu będziesz w stanie zagwarantować czas wymagany przez arkusz danych.

Przyjemną zaletą tego jest to, że wyświetlacz LCD będzie wyglądał jak każda stara pamięć zamapowana na urządzenia peryferyjne, oddzielając szczegóły interfejsu niższego poziomu.