STM32

Dois IDEs que gosto e dois que odeio

No princípio você descobre o Dev-C++ começa a programar e os bugs te atormentam. Não lembro quais são eles mas me fez procurar alternativas e encontrei o caso de amor:

Code::Blocks – O profissional

Feito para ser uma alternativa ao Dev-C++ já deixou de ser alternativa e se tornou regra. Evoluiu muito e tem cada vez mais agregado funcionalidades úteis.

Captura de tela de 2016-07-01 19-47-20 - 1.png

Como se pode ver na figura os Templates são variados e nos ultimos releases há uma busca pelo desenvolvimento embarcado se aproveitando das diversas plataformas suportadas pelo GCC e o SDCC.

O Code::Blocks suporta desde o começo muitos compiladores. No Windows o download já vem embutido o Mingw ou TDM-GCC.

Eu uso ele profissionalmente para desenvolvimento C/C++ para as plataformas ARM (STM32 ou Kinetis) e AVR bem como x86. Deu um pouco de trabalho a configuração inicial dele para STM32 mas foi gratificante e muito instrutivo.

Captura de tela de 2016-07-01 19-59-01.png

O que mais gosto nele é facilidade de configuração e início médio. Eu odeio programas lentos como se verá nos que odeio. Mas ainda há uma opção veloz …

Geany – O pequeno poderoso

Eu adoro o Geany. É o IDE perfeito para testes rápidos e desenvolvimentos descompromissados. Diferente do Code:Blocks ele suporta diversas linguagens e tenho usado muito ultimante para Python.

Apesar de ter a opção de criar projetos o que me atrai nele é justamente você poder criar um arquivo, digitar o código e botar para rodar diretamente sem maiores burocracias. Por isso é perfeito para testes.E ao fechá-lo e abri-lo posteriormente as abas estarão lá abertas novamente.  Na verdade um projeto é nada mais que organizar seus arquivos em pastas que são navegáveis no painel “Aquivos” ao lado. Se o projeto cresceu então junte tudo em uma pasta e trabalhe com ela.

Captura de tela de 2016-07-01 20-03-43.png

E o inicio é rapido!

Como eu gosto disto! Clicou abriu! E o terminal embaixo? Quebra um galhão. Com um suporte a debug  ele pode até substituir o Code::Blocks.

linux_dark_1-24_weblinux_dark_1-24

As caras são muitas ao Geany para todos os gostos. Acho bonito programar em escuro mas não consigo me acostumar.

Os que odeio

Eclipse – Lerdeza

Pelo amor de Deus … como demora esta coisa para iniciar. Fiquei injuriado quando a Freescale mudou sua IDE para variantes Eclipse. Clicava em debug e aquela coisa ficava pensando … pensando … indexando. Que horror. Por isso fiz um esforço e aprendi a configurar o Code::Blocks para ARMs.

Essa tendência de se fazer IDEs baseadas no Eclipse para mim foi um desastre. A Texas fez isso, a Freescale e a ST esta indo no caminho. Sim, sim sei que o Eclipse é muito versátil mas convenhamos muito lento.  Certeira foi a Atmel que partiu para uma solução Visual Studio.

plc2-2015-your-own-ide-4-638

E aquela burocracia para se criar um projeto???? O sujeito que programa para sistemas embarcados em Eclipse se aprender diretamente nele se torna dependente do mesmo; porque não terá a menor noção de como se programa para uma plataforma: que comandos, que bibliotecas, que caminhos, como usar os comandos de debug. Tudo isso fica escondido em trezentos cliques que da medo e preguiça de mexer.

Se você usa o Eclipse e não tem a menor idéia de como as coisas funcionam por favor veja neste post como se programa “na mão”  um STM32.

Descobri neste site http://www.ihateeclipse.com  que não sou o único!

Vim/VI – O Geek

Fui atrás de um screenshot deles no Google e o que acho? Curiosamente mais destas imagens que do próprio em questão. Isto já diz tudo:

vi-vim-cheat-sheet

Ai vem aquele moleque que quer ser diferente e se acha o maior por usar um desses.

A primeira instalação que fazia em algum Linux novo  – antigamente pois depois do ArchLinux nunca mais fiz instalação nova – era o MCEdit para evitar ter que editar arquivos de configurações nesta !@#$!. Aliás como se sai mesmo dele?  Era algo como ESC-Q!.

Eu não odeio o Terminal. Eu adoro o modo texto! Uso demais o Guake (terminal suspenso), mas perder meu tempo aprendendo esses atalhos se posso usar um IDE mais robusto não é comigo.

Fazer um esforço para aprender estes comandos para mim é uma perda de tempo se posso aprender muitas outras coisas mais úteis. De fato no momento estou fazendo um esforço para escrever robôs investidores em Forex e Bolsa e estou adorando o tema em torno de processos estocásticos. O Geany e o Metatrader estão sendo perfeitos para isso.

main-qimg-cf12b776c0e69ec6d30a47b0d90792d9

Geração dodói

Se você programa nestas coisas parabéns te admiro, mas não me pertube.

 

 

 

Seleção de utilidades para o hobby eletrônico no AliExpress

Sabe aqueles vídeos ou fotos de pessoas que realizam diversas montagens nos protoboards com aqueles fios bonitinhos, usando aqueles módulos pequenos e úteis ou placas padrão? Então. Lembro-me que achava que nunca conseguiria ter tudo aquilo. Porém depois de descobrir o AliExpress lá atrás devagar fui comprando pequenas utilidades sem gastar mais que R$ 50,00 por entrega (já que algumas levam algumas semanas para chegar). Se eu tivesse comprado no Brasil estaria perdido, falido esta hora.

Então segue um lista que acho útil e talvez você não conseguiu achar por não saber os nomes.

 

male-to-male-color-breadboard-cable-jump-wire-font-b-jumper-b-font-for-font-b_220x220 free-shipping-straight-curve-font-b-tweezers-b-font-eyelash-extension-tool-eyelash-makeup-beauty-stainless_220x220 usb-font-b-logic-b-font-font-b-analyzer-b-font-100m-max-sample-rate-16channels_220x220

Três ferramentas de extrema utilidade. 40 Fios com terminais por U$ 2,40. Pinças de boa qualidade. E um analisador lógico indispensável para depurar saidas de MCUs. Checar 6 canais de PWM sem um destes é loucura…

2015-new-mb102-power-supply-module-3-3v-5v-breadboard-board-830-point-65pcs-font-b_220x220

Os pacotes se bem achados são muito econômicos. E esse é o grande diferencial do AliExpress. Isto tudo ai sai por somente U$ 5,60. O módulo de fonte pode ser alimentado por USB ou a fonte de 9V do Arduino. Tem LED, 3.3v/5v e chave liga-desliga. O módulo foi feito para se encaixar perfeitamente no protoboard.

with-the-bootloader-font-b-nano-b-font-3-0-controller-compatible-for-font-b-arduino_220x220

Por menos de U$ 3,00 você leva esse Arduino Nano e pode transformá-lo em gravador ISP e conectar direto na protoboard. Tem a mesma capacidade dos Arduinos normais porém menor e prático.

20pcs-5x7-4x6-3x7-2x8-cm-double-side-copper-prototype-font-b-pcb-b-font-font_220x2201 qfn-tqfp-font-b-lqfp-b-font-qfp-16-80-pin-0-5mm-pitch-to-dip_220x220

Uma hora um projeto tem que ficar definitivo. E estas placas ajudam muito. Feitas em fibras são ótimas. Também as adaptadoras de CIs SMDs são extremamente úteis.

1pcs-usb-to-font-b-ttl-b-font-uart-module-ch340g-ch340-3-3v-5v-font_220x220

Úteis para qualquer desenvolvedor para MCUs. Estes módulos de comunicação serial também servem para alimentação 3.3.V/5V baixa corrente. Ligue o terra o positivo e RX com TX e pronto você tem uma forma de debugar seus programas. Compre uns 5 desses porque qualquer besteira sua e adeus módulo.

ac-100v-240v-converter-adapter-dc-9v-1a-font-b-power-b-font-font-b-supply_220x220 new-high-quality-5v-2a-v8-us-micro-usb-charger-charging-adapter-font-b-power-b_220x220

Seleção de fontes. A primeira de 9V para o Arduino e a ultima para o Raspberry Pi com 5V/2A.

free-shippin-5pcs-lot-font-b-atmega328p-b-font-pu-font-b-atmega328p-b-font-dip_220x220 the-original-5pcs-font-b-attiny85-b-font-20pu-font-b-attiny85-b-font-20pu-font_220x220 1pcs-stm32f103c8t6-arm-font-b-stm32-b-font-minimum-system-development-board-module-for-arduino_220x220

Quanto é um ATMEGA328P no Brasil? Que tal pelo mesmo preço comprar 5? E o Attiny85? E por ultimo os STM32 são uma boa pedida para começar a programar para ARM e arquiteturas 32 bits. Todos sem dúvida irão precisar de um gravador.  No caso dos Atmel o Arduino Nano já mostrado acima serve. Para o STM32 o STLINK pelo mesmo preço grava STM8 e STM32.

 

Bom espero que tenha sido útil. Montar uma bancada aos poucos com diversos CIs equipamentos vai lhe trazer um diferencial no desenvolvimento, aprendizado rico e economizar muita grana se tiver paciência e comprar na China. Agora o AliExpress aceita pagamentos por Boleto facilitando para os jovens sem conta em banco.

O meu carrinho vive cheio de coisas no site. É uma perdição.

 

STM32 no Linux

Programar Kits ou microcontroladores STM32 no Linux é perfeitamente possível graças ao GNU ARM Toolchain para tanto é necessário instalar este e outros pacotes primos como veremos neste post. Será mostrado aqui a instalação destes pacotes e um simples programa blink sem bibliotecas de suporte.

Há vários toolchains disponíveis para uC ARMs alguns que se utilizam das syscall de algum SO como o Linux e outros que não esperam nenhum Sistema Operacional por trás, programar assim é chamado comumente como ‘baremetal’.

Para debugar e gravar um STM32 será utilizado o ST-Util e o OpenOCD.

Instalando os pacotes

GCC + GDB + OpenOCD

Eu utilizo o ArchLinux mas não poderia discriminar o Ubuntu.
Para o Ubuntu:

sudo add-apt-repository ppa:terry.guo/gcc-arm-embedded
sudo apt-get update
sudo apt-get install gcc-arm-none-eabi
sudo apt-get install gdb-arm-none-eabi
sudo apt-get install openocd

ArchLinux users:

sudo pacman -S arm-none-eabi-binutils arm-none-eabi-gcc arm-none-eabi-gdb arm-none-eabi-newlib openocd stlink

Se tudo ocorreu corretamente teste a instalação abrindo um shell e digitando arm-none <TAB> isso fará o bash autocompletar a sequência e mostrar os executáveis instalados como nesta saída tipica:

arm-none-eabi-addr2line arm-none-eabi-gcc-4.7.4 arm-none-eabi-ld.bfd
arm-none-eabi-ar arm-none-eabi-gcc-ar arm-none-eabi-nm
arm-none-eabi-as arm-none-eabi-gcc-nm arm-none-eabi-objcopy
arm-none-eabi-c++ arm-none-eabi-gcc-ranlib arm-none-eabi-objdump
arm-none-eabi-c++filt arm-none-eabi-gcov arm-none-eabi-ranlib
arm-none-eabi-cpp arm-none-eabi-gdb arm-none-eabi-readelf
arm-none-eabi-elfedit arm-none-eabi-gdbtui arm-none-eabi-size
arm-none-eabi-g++ arm-none-eabi-gprof arm-none-eabi-strings
arm-none-eabi-gcc arm-none-eabi-ld arm-none-eabi-strip

Primeiro Programa

Antes de tudo vamos iniciar a configuração do vetor de interrupções, a routina de reset e alguns Defines para alguns registradores que iremos usar. Este programa foi feito para o kit STM32 Discovery F0. Com poucas modificações e entendendo o processo a migração para outros (M3/M4) será fácil.

O primeiro arquivo boot.h contém alguns typedefs e Defines para registradores de clock e GPIOs, declaração de váriaveis externas do arquivo de link, prototypes de funções e o vetor de interrupções (que neste caso só cobrirá as interrupções ARM). Também o Reset e SystemInit bem como as funções de tratamento de interrupções serão declaradas.

boot.h

// boot.h
#define uint32_t unsigned int
#define IO_Uint32 volatile unsigned int
typedef struct
{
IO_Uint32 ACR;
IO_Uint32 KEYR;
IO_Uint32 OPTKEYR;
IO_Uint32 SR;
IO_Uint32 CR;
IO_Uint32 AR;
IO_Uint32 RESERVED;
IO_Uint32 OBR;
IO_Uint32 WRPR;
} _FLASH;

typedef struct
{
IO_Uint32 CR;
IO_Uint32 CFGR;
IO_Uint32 CIR;
IO_Uint32 APB2RSTR;
IO_Uint32 APB1RSTR;
IO_Uint32 AHBENR;
IO_Uint32 APB2ENR;
IO_Uint32 APB1ENR;
IO_Uint32 BDCR;
IO_Uint32 CSR;
IO_Uint32 AHBRSTR;
IO_Uint32 CFGR2;
IO_Uint32 CFGR3;
IO_Uint32 CR2;
} _RCC;

typedef struct {
IO_Uint32 MODER;
IO_Uint32 OTYPER;
IO_Uint32 OSPEEDR;
IO_Uint32 PUPDR;
IO_Uint32 IDR;
IO_Uint32 ODR;
IO_Uint32 BSRR;
IO_Uint32 LCKR;
IO_Uint32 AFRL[2];
IO_Uint32 BRR;
} _GPIO ;

#define GPIOC ((_GPIO *) 0x48000800)
#define RCC ((_RCC *) 0x40021000)
#define FLASH ((_FLASH *) 0x40022000)

// Globais do arquivo do linker
extern void *_estack;
extern unsigned char _sidata;
extern unsigned char _sdata;
extern unsigned char _edata;
extern unsigned char _sbss;
extern unsigned char _ebss;
extern void main (void);

// Entry Point
void Reset (void);
// Default Interrupt Handler
void Default_Handler(void) __attribute__( ( interrupt ) );
static void HardFault_Handler( void )/* __attribute__( ( naked ) )*/;

__attribute__ ((section(".isr_vector")))
void (* const Vectors[])(void) = {
(void(*)(void)) &amp;_estack,
Reset,
Default_Handler, //NMI_Handler,
HardFault_Handler, //FaultHandler,
0,
0,
0,
0,
0,
0,
0,
Default_Handler, //SVC_Handler,
0,
0,
Default_Handler, //PendSV_Handler,
Default_Handler, //SysTick_Handler,
};

static void HardFault_Handler( void ){
__asm__("BKPT");
while (1);
}

#pragma weak _exit = Default_Handler
void Default_Handler(void) {
__asm__("BKPT");
while (1);
}

void SystemInit(void)
{
/* Reseta o RCC clock para  o padrão ------------*/
/* Set HSION bit */
RCC-&gt;CR |= (uint32_t)0x00000001;

/* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
RCC-&gt;CFGR &amp;= (uint32_t)0x08FFB80C;

/* Reset HSEON, CSSON and PLLON bits */
RCC-&gt;CR &amp;= (uint32_t)0xFEF6FFFF;

/* Reset HSEBYP bit */
RCC-&gt;CR &amp;= (uint32_t)0xFFFBFFFF;

/* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
RCC-&gt;CFGR &amp;= (uint32_t)0xFFC0FFFF;

/* Reset PREDIV[3:0] bits */
RCC-&gt;CFGR2 &amp;= (uint32_t)0xFFFFFFF0;

/* Reset USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits */
RCC-&gt;CFGR3 &amp;= (uint32_t)0xFFFFFE2C;

/* Reset HSI14 bit */
RCC-&gt;CR2 &amp;= (uint32_t)0xFFFFFFFE;

/* Desabilita todas as interrupções*/
RCC-&gt;CIR = 0x00000000;

FLASH-&gt;ACR = 0x00000011;

}
// O começo de tudo antes de main
__attribute__( ( naked ) ) void Reset (void) {

register unsigned char *src, *dst;

// Copia os dados da flash para a ram (const, static initialized variables)
src = &amp;_sidata;
dst = &amp;_sdata;
while(dst &lt; &amp;_edata) *dst++ = *src++;

// Inicializa o bss (C static variables non initialized)
dst = &amp;_sbss;
while(dst &lt; &amp;_ebss) *dst++ = 0;

SystemInit();
//__libc_init_array();
// ... and finally call main saving sp
__asm__("b main");

}

A função Reset inicializa a variáveis estáticas com zero, chama SystemInit e finalmente chama a função Main com um brunch para economizar RAM na pilha.

main.h

O segundo arquivo é o fluxo principal do programa onde esta a função Main. Este programa irá piscar os LEDs do kit nas portas PC9 e PC8. O tipo GPIO foi declarado anteriormente em boot.h.

#include "boot.h"

__attribute__( ( naked ) ) void main (void){

RCC-&gt;AHBENR |= ((unsigned int) 0x00080000); // Enable GPIOC otherwise a hardfault
GPIOC-&gt;MODER = 0x55555555; // Output mode for all PORTC

volatile register int i;

while (1) {

GPIOC-&gt;BSRR = 0x0000ffff;
for (i = 0; i &lt; 50000; i++); GPIOC-&gt;BSRR = 0xffff0000;
for (i = 0; i &lt; 50000; i++);

};

__asm__("b .");
};

Makefile e Link Script

Acabou? Não  Ainda faltam dois arquivos o MakeFile e o Script do Linker.

Este MakeFile é completo o que compilará, mostrará o tamanho do código, converterá ELF para BIN, irá gerar uma listagem em assembly e finalmente grava na flash o programa. Simplesmente execute o make no terminal de onde estão estes arquivos.

all:
arm-none-eabi-gcc -mcpu=cortex-m0 -gdwarf-2 -mthumb -nostdlib -mlittle-endian -Tlink.ld main.c -o main
arm-none-eabi-size main
arm-none-eabi-nm -S main
arm-none-eabi-objdump -d -M intel -S main &gt; bin.asm
arm-none-eabi-objcopy -O binary main main.bin
st-flash erase
st-flash --reset write main.bin 0x08000000
debug:
arm-none-eabi-gdb main -tui --eval-command="target extended-remote :4242"

E por fim o link  script. Lugar onde as posições de memória são definidos, o Entry Point e algumas globais usadas pelo Reset para inicializar a variáveis estaticas e constantes.

/* Entry Point */
ENTRY(Reset)

/* Highest address of the user mode stack */
_estack = 0x20001FFF; /* end of RAM */

/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0; /* Only usefull if you use alloc, malloc */
_Min_Stack_Size = 0x800;

MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 64K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 8K
}

/* Define output sections */
SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} &gt;FLASH

/* The program code and other data goes into FLASH */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)

KEEP (*(.init))
KEEP (*(.fini))

. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} &gt;FLASH

/* Constant data goes into FLASH */
.rodata :
{
. = ALIGN(4);
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} &gt;FLASH

.ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } &gt;FLASH
.ARM : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} &gt;FLASH

.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} &gt;FLASH
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} &gt;FLASH
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} &gt;FLASH

/* used by the startup to initialize data */
_sidata = LOADADDR(.data);

/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */

. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} &gt;RAM AT&gt; FLASH

/* Uninitialized data section */
. = ALIGN(4);
.bss :
{
_sbss = .; /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)

. = ALIGN(4);
_ebss = .; /* define a global symbol at bss end */
__bss_end__ = _ebss;
} &gt;RAM

._user_heap_stack :
{
. = ALIGN(4);
PROVIDE ( end = . ); /* Necessary for newlibc */
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(4);
} &gt;RAM

/* Remove information from the standard libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
}

.ARM.attributes 0 : { *(.ARM.attributes) }
}

Foi apresentado aqui como programar microcontroladores STM32 no Linux utilizando as ferramentas gratuitas disponíveis. Não utilizei o conjunto de bibliotecas oficiais da ST chamado Cube para demonstrar também como é um programar um uC sem este suporte.

Como evolução o leitor irá integrar o Cube e utilizar o CubeMX para facilmente inicializar o uC e partir para a programação em si.

Eu programo microcontroladores STM32 no Linux profissionalmente com estas ferramentas e integro tudo no Code:Blocks que é uma ótima alternativa aos ambientes caros como IAR e Keil. Eu não me adaptei muito aos derivados gratuitos do Eclipse porque não gosto de programas que demoram para inicializar …

EDIT: O WordPress vive mudando meu código postado transformando caracteres especiais em formato HTML Entity e não sei como mudar isso. Se alguém ai souber me ajude por favor porque se você copiar e colar os códigos daqui será necessário corrigir muita pontuação.

ARM – SysTick fácil.

SysTick é um timer decrescente presente na maioria dos processadores ARM Cortex ligado diretamente ao Core Clock com registrador de 24 Bits.

O SysTick gera interrupção a cada estouro do contador, ou seja, quando chega em 0. Para configurar usando os registradores diretamente segue exemplo:

SysTick->CTRL = 0; // Desliga o SysTick
SysTick->LOAD = 1000; // Conta de 1000 até 0
SysTick->VAL = 0; // Valor inicial, e também valor da contagem atual
SysTick->CTRL = 0x7; // Liga o SysTick

Ou para quem tiver disponível os arquivos CMSIS (muito provavelmente) este pode ser inicializado diretamente:

Neste caso estabelecemos um estouro a cada 1ms

SysTick_Config(SystemCoreClock / 1000) ;

Neste o loop while trava se um valor impossível for inicializado.

while (SysTick_Config(48000000 / 2) != 0);  // 48Mhz / 2 = 24Mhz

Ótima opção para iniciar no mundo ARM.

Lembre-se que o tamanho máximo do contador é de 24 bits o que representa um valor decimal de 16777216. Assim dividir o 48Mhz por 2 retorna uma valor maior que o máximo possível. Deu para perceber que conseguir 1 Segundo de estouro só é possível em clocks mais baixo.

Para que as interrupções ocorram não esqueça de definir uma função (Handler) que deve estar adicionada na Vector Table:

void (* const g_pfnVectors[])(void) = {
&_estack,
Reset_Handler,
NMI_Handler,
FaultHandler,
0,
0,
0,
0,
0,
0,
0,
SVC_Handler,
0,
0,
PendSV_Handler,
SysTickIsr, //Função SysTickIsr que será chamada a cada estouro
};