Po automatycznym zainstalowaniu się sterownika J-Link można przejść do sprzętowego debugowania naszego programu migania diodami LED. Kiedy debugger J-link jest podłączony do komputera, to otwiera się automatycznie okno Segger J-Link Control panel – rysunek 15.
Rys. 15. Okno sterujące sprzętowego debuggera Segger J-Link
Debugowanie jest uruchamiane po kliknięciu na ikonkę przypominającą owada (rysunek 16) i wybraniu Debug As->Renesas GDB Hardware Debugging.
Rys. 16. Uruchamianie debugowania w środowisko e2studio
Debbuger programu e2studio działa podobnie jak w środowiskach IDE innych producentów. Do sterowania debugowaniem używa się następujących ikonek:
uruchom program
zatrzymaj program
zakończ debugowanie
odłącz proces debugowania
wykonanie jednego kroku programu z wejściem do funkcji
wykonanie całej funkcji
krok powrotu
debugowanie instrukcji assemblera
usuń wszystkie punkty zatrzymania (breakpoints)
zapisz program do pamięci
zeruj debugger
zeruj mikrokontroler (działanie programu)
odśwież
Po uruchomieniu debugowania automatycznie otwierają się okna: Debug, Project Explorer, okno z debugowanym kodem i Disassembly – rysunek 17. W oknie z debugowanym kodem będziemy oglądać wykonywanie programu napisanego w C, a w oknie Dissasembly kod w asemblerze.
Teraz możemy zobaczyć jak się wykonuje nasz kod z listingu 1. Program nie zatrzymuje się na wywołaniu procedury z funkcji main(), ale najpierw na procedurze funkcji Reset_Handler() – listing 3.
Rys. 17. Okna z debugowanym kodem
List. 3. Funkcja Reset_Handler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/********************************************************************************* * Function Name: Reset_Handler * Description : MCU starts executing here out of reset. Main stack pointer is setup already. * Arguments : none * Return Value : none *********************************************************************************/ void Reset_Handler (void) { /* Initialize system using BSP. */ SystemInit(); /* Call user application. */ main(); while (1) { /* Infinite Loop. */ } } |
Jest to funkcja wywoływana po zerowaniu mikrokontrolera i dopiero ona wywołuje główna funkcję main(). Jednak zanim to nastąpi wywoływana jest funkcja System Init() umieszczona w pliku startup_S7G2.c i pokazana na listingu 4.
List. 4. Funkcja inicjalizacji mikrokontrolera
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
********************************************************************************* * Function Name: SystemInit * Description : Setup MCU. * Arguments : none * Return Value : none *********************************************************************************/ void SystemInit (void) { #if (defined (__GNUC__) && defined (__VFP_FP__) && !defined (__SOFTFP__)) || \ (defined (__ICCARM__) && defined (__ARMVFP__) && (__FPU_PRESENT == 1)) /* Enable the Cortex-M4 FPU only when -mfloat-abi=hard. Code taken from Section 7.1, Cortex-M4 TRM (DDI0439C) */ /* Set bits 20-23 to enable CP10 and CP11 coprocessor */ SCB->CPACR |= (0xF << 20); #endif /* Call Pre C runtime initialization hook. */ R_BSP_WarmStart(BSP_WARM_START_PRE_C); /* Initialize grouped interrupts. */ bsp_group_interrupt_open(); /* Configure system clocks using CGC module. */ bsp_clock_init(); /* Initialize register protection. */ bsp_register_protect_open(); /* Handle VBTICTLR register. */ bsp_vbatt_init(&g_bsp_pin_cfg); /* Initialize pins. */ g_ioport_on_ioport.init(&g_bsp_pin_cfg); /* Initialize C runtime environment. */ /* Zero out BSS */ #if defined(__GNUC__) bsp_section_zero((uint8_t *)&__bss_start__, ((uint32_t)&__bss_end__ - (uint32_t)&__bss_start__)); #elif defined(__ICCARM__) bsp_section_zero((uint8_t *)__section_begin(".bss"), (uint32_t)__section_size(".bss")); #endif /* Copy initialized RAM data from ROM to RAM. */ #if defined(__GNUC__) bsp_section_copy((uint8_t *)&__etext, (uint8_t *)&__data_start__, ((uint32_t)&__data_end__ - (uint32_t)&__data_start__)); #elif defined(__ICCARM__) bsp_section_copy((uint8_t *)__section_begin(".data_init"), (uint8_t *)__section_begin(".data"), (uint32_t)__section_size(".data")); /* Copy functions to be executed from RAM. */ #pragma section=".code_in_ram" #pragma section=".code_in_ram_init" bsp_section_copy((uint8_t *)__section_begin(".code_in_ram_init"), (uint8_t *)__section_begin(".code_in_ram"), (uint32_t)__section_size(".code_in_ram")); #endif /* Initialize SystemCoreClock variable. */ SystemCoreClock = bsp_cpu_clock_get(); /* Call Post C runtime initialization hook. */ R_BSP_WarmStart(BSP_WARM_START_POST_C); /* Initialize the Hardware locks to 'Unlocked' */ bsp_init_hardware_locks(); /* Initialize ELC events that will be used to trigger NVIC interrupts. */ bsp_irq_cfg(); /* Initialize ELC. */ g_elc_on_elc.init(&g_elc_cfg); /* Call any BSP specific code. No arguments are needed so NULL is sent. */ bsp_init(NULL); } |
Zgodnie z przewidywaniami inicjalizacja jest dość rozbudowana i zawiera procedury ustawiające między innymi taktowanie, system przerwań, protekcję zapisu rejestrów, inicjowanie linii GPIO itp.
Każdą z funkcji inicjalizujących można w debugerze wykonywać krokowo i posiłkując się dokumentacją mikrokontrolera patrzeć jak postępuje konfigurowanie mikrokontrolera. Możemy jako przykład zobaczyć jak wygląda ustawianie taktowania mikrokontrolera wykonywane przez procedurę bsp_clock_init – listing 5.
List. 5. Konfigurowanie taktowania mikrokontrolera
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
/*********************************************************************************//** * @brief Sets up system clocks. *********************************************************************************/ void bsp_clock_init (void) { g_cgc_on_cgc.init(); /** MOCO is default clock out of reset. Enable new clock if chosen. */ cgc_clock_t clock; if (BSP_CFG_CLOCK_SOURCE != CGC_CLOCK_PLL) { clock = BSP_CFG_CLOCK_SOURCE; g_cgc_on_cgc.clockStart(clock, NULL); } else { /** Need to start PLL source clock and let it stabilize before starting PLL */ clock = BSP_CFG_PLL_SOURCE; g_cgc_on_cgc.clockStart(clock, NULL); cgc_clock_cfg_t pll_cfg; /** Set PLL Divider. */ pll_cfg.divider = BSP_CFG_PLL_DIV; /** Set PLL Multiplier. */ pll_cfg.multiplier = BSP_CFG_PLL_MUL; /** Set PLL Source clock. */ pll_cfg.source_clock = clock; while (SSP_ERR_STABILIZED != g_cgc_on_cgc.clockCheck(clock)) { /** Wait for PLL clock source to stabilize */ } g_cgc_on_cgc.clockStart(CGC_CLOCK_PLL, &pll_cfg); clock = CGC_CLOCK_PLL; } R_ROMC->ROMCE_b.ROMCEN = 1; /** Enable ROM cache */ /** MOCO, LOCO, and subclock do not have stabilization flags that can be checked. */ if ((CGC_CLOCK_MOCO != clock) && (CGC_CLOCK_LOCO != clock) && (CGC_CLOCK_SUBCLOCK != clock)) { while (SSP_ERR_STABILIZED != g_cgc_on_cgc.clockCheck(clock)) { /** Wait for clock source to stabilize */ } } cgc_system_clock_cfg_t sys_cfg; sys_cfg.iclk_div = BSP_CFG_ICK_DIV; sys_cfg.pclka_div = BSP_CFG_PCKA_DIV; sys_cfg.pclkb_div = BSP_CFG_PCKB_DIV; sys_cfg.pclkc_div = BSP_CFG_PCKC_DIV; sys_cfg.pclkd_div = BSP_CFG_PCKD_DIV; sys_cfg.fclk_div = BSP_CFG_FCK_DIV; sys_cfg.bclk_div = BSP_CFG_BCK_DIV; /** Set which clock to use for system clock and divisors for all system clocks. */ g_cgc_on_cgc.systemClockSet(clock, &sys_cfg); /** Set USB clock divisor. */ g_cgc_on_cgc.usbClockCfg(BSP_CFG_UCK_DIV); /** Configure BCLK */ #if BSP_CFG_BCLK_OUTPUT == 1 g_cgc_on_cgc.busClockOutCfg(CGC_BCLOCKOUT_DIV_1); g_cgc_on_cgc.busClockOutEnable(); #elif BSP_CFG_BCLK_OUTPUT == 2 g_cgc_on_cgc.busClockOutCfg(CGC_BCLOCKOUT_DIV_2); g_cgc_on_cgc.busClockOutEnable(); #else g_cgc_on_cgc.busClockOutDisable(); #endif /** Configure SDRAM Clock */ #if BSP_CFG_SDCLK_OUTPUT == 0 g_cgc_on_cgc.sdramClockOutDisable(); #else g_cgc_on_cgc.sdramClockOutEnable(); #endif } |
