STM32F4 Discovery Geliştirme Kiti İncelemesi

Bu yazımızda ST firmasının henüz satışa sunduğu STM32F4 Discovery kitini inceleyeceğiz. Kit üzerinde ARM Cortex M4 tabanlı 168 MHz’lik bir mikrodenetleyici bulunuyor. Cortex M4′den kısaca bahsetmek gerekirse; Bu mimari standart mikrodenetleyici uygulamalarının yanısıra DSP fonksiyonlarını da içinde barındıran bir mimari.

ARM’ın Cortex M3 çekirdeğinde sadece mikrodenetleyici uygulamaları esas alınmış. Fakat M4 çekirdeğinde ise M3′e ekstra olarak bir de FPU(Floating Point Unit) bulunuyor. Bu aslında kit üzerindeki M4 çipinin sadece bir artısı daha ileride sayacağımız birçok ekstra özellik de kit ile beraber gelen mikrodenetleyici içerisinde bulunuyor.

Çip içerisinde FPU’nun bulunması demek ondalıklı işlemler için tasarlanmış ekstra bir birim demek ve DSP uygulamalarının vazgeçilmezi demek. Bu sebepten de ST firması yandaki resimde gördüğünüz kartı tasarlarken kit üzerinde bir mikrofon ve ses çıkış jakı da eklemiş ;)

 

 

STM32F4 Geliştirme Kiti Donanımı

  • 32-bit ARM Cortex-M4F çekirdeğine sahip STM32F407VGT6 mikrodenetleyicisi, 1 MB Flash ve 192 KB RAM
  • Dahili ST-LINK/V2 JTAG Debugger
  • USB veya harici kaynaktan doğrudan 5v ile çalışabilme
  • 3 V ve 5 V luk çıkış pinleri
  • 3-eksen dijital ivmeölçer (LIS302DL)
  • Omni-Directional Mikrofon (MP45DT02)
  • D sınıfı yükselteçli ses sürücü çipi(CS43L22)
  • Sekiz adet LED:
    • LD1 (kırmızı/yeşil)(USB haberleşmesi için)
    • 3v3 power on/off LEDi
    • Dört adet kullanıcı LEDi, LD3 (turuncu), LD4 (yeşil), LD5 (kırmızı) ve LD6 (mavi)
    • 2 adet USB OTG LEDi, LD7 (yeşil) ve LD8 (kırmızı)
  • Bir adet Reset ve bir adet kullanıcı tanımlı buton
  • USB OTG için mikro-AB konnktör.
  • 100 pin’in tamamını kullanabilmeye imkan tanıyan çıkışlar.

STM32F407VG Mikrodenetleyicisinin Özellikleri

  • Core: ARM 32-bit Cortex™-M4F CPU with FPU, Adaptive real-time accelerator (ART Accelerator™) allowing 0-wait state execution from Flash memory, frequency up to 168 MHz, memory protection unit, 210 DMIPS/1.25 DMIPS/MHz (Dhrystone 2.1), and DSP instructions
  • Memories
    • Up to 1 Mbyte of Flash memory
    • Up to 192+4 Kbytes of SRAM including 64-Kbyte of CCM (core coupled memory) data RAM
    • Flexible static memory controller supporting Compact Flash, SRAM, PSRAM, NOR and NAND memories
  • LCD parallel interface, 8080/6800 modes
  • Clock, reset and supply management
    • 1.8 V to 3.6 V application supply and I/Os
    • POR, PDR, PVD and BOR
    • 4-to-26 MHz crystal oscillator
    • Internal 16 MHz factory-trimmed RC (1% accuracy)
    • 32 kHz oscillator for RTC with calibration
    • Internal 32 kHz RC with calibration
    • Sleep, Stop and Standby modes
    • VBATsupply for RTC, 20×32 bit backup registers + optional 4 KB backup SRAM
  • 3×12-bit, 2.4 MSPS A/D converters: up to 24 channels and 7.2 MSPS in triple interleaved mode
  • 2×12-bit D/A converters
  • General-purpose DMA: 16-stream DMA controller with FIFOs and burst support
  • Up to 17 timers: up to twelve 16-bit and two 32-bit timers up to 168 MHz, each with up to 4 IC/OC/PWM or pulse counter and quadrature (incremental) encoder input
  • Debug mode
    • Serial wire debug (SWD) & JTAG interfaces
    • Cortex-M4F Embedded Trace Macrocell™
  • Up to 140 I/O ports with interrupt capability
    • Up to 136 fast I/Os up to 84 MHz
    • Up to 138 5 V-tolerant I/Os
  • Up to 15 communication interfaces
    • Up to 3 × I2C interfaces (SMBus/PMBus)
    • Up to 4 USARTs/2 UARTs (10.5 Mbit/s, ISO 7816 interface, LIN, IrDA, modem control)
    • Up to 3 SPIs (37.5 Mbits/s), 2 with muxed full-duplex I2S to achieve audio class accuracy via internal audio PLL or external clock
    • 2 × CAN interfaces (2.0B Active)
    • SDIO interface
  • Advanced connectivity
    • USB 2.0 full-speed device/host/OTG controller with on-chip PHY
    • USB 2.0 high-speed/full-speed device/host/OTG controller with dedicated DMA, on-chip full-speed PHY and ULPI
    • 10/100 Ethernet MAC with dedicated DMA: supports IEEE 1588v2 hardware, MII/RMII
  • 8- to 14-bit parallel camera interface up to 54 Mbytes/s
  • Analog random number generator
  • CRC calculation unit, 96-bit unique ID
  • RTC: subsecond accuracy, hardware calendar
SM32F4 Kiti ve STM32F407VG çipi için ST referans bağlantılarını aşağıda bulabilirsiniz.
Aşağıdaki resimde Cortex M0 – M3 – M4 karşılaştırmasını görebilirsiniz.
Resimde görüldüğü gibi M3 – M4 arasındaki temel fark, DSP donanımı ve buna bağlı olarak da DSP komutları işleyebilme yeteneği.

Diğer kısımlarda Cortex M3 e nazaran ekstra bir birim yok. Bu da Cortex M3 kullanıcılarnın, Cortex M4′e kolay uyum sağlayacağı anlamına geliyor ;)

Aşağıda ise STM32F4 Discovery Kiti üzerindeki donanımları gösteren bir resim bulunmakta.

Kit üzerinde başlangıç için fazlasıyla yeterli olabilecek donanım bulunuyor. Örneğin mikrofondan aldığınız sesi dijitale çevirmek için I2S protokolünü veya STM32F4′ün DAC’ını kullanabiliyorsunuz. 3-eksen ivmeölçer’den bilgileri SPI ya da I2C kullanarak okuyabiliyorsunuz. USB için OTG çıkışı ve durum LED’leri de mevcut. Ayrıca kit üzerinde gelen yazılım 3-eksen ivmeölçer etrafındaki 4 adet LED’i eğime göre yakıyor. Bu şekilde LED’leri de debug için pratik bir şekilde kullanmak mümkün.

Bir de ST’nin ARM için sunduğu kütüphaneleri kullanırsanız işiniz bir hayli kolaylaşıyor. Bu şekilde çip manualini temel düzeyde okuyup kullanacağınız donanımın özelliklerini az çok bildikten sonra ST kütüphaneleri ile yazılımı yazmanız çok kolay olacaktır.

Bu yazıyı hazırlamadan önce ben de aynen bu şekilde Keil‘da örnek bir iki uygulama gerçekleştirdim. Eğer neyi nasıl yapacağınızı bilirseniz bu kit kısa zamanda elinizde güzel bir oyuncağa dönüşecektir ;)
Şimdi Keil Programını kullanarak temel ayarların nasıl yapıldığına değinelim.

Yeni Proje…

Yeni bir proje oluşturduğumuzda kullanacağımız çipi seçtikten sonra ilk yapmamız gereken şey donanım ile mi yoksa simulatör ile mi çalışacağımızı bellirlemektir. Keil’da bunu aşağıdaki menüden ayarlayabiliriz. Kitimizin en büyük avantajı üzerinde dahili debugger donanımını da barındırması. Ve istenildiğinde başka çiplerin bu kit aracılığıyla programlanabilmesi.

Ardından Target sekmesine tıklayıp xtall parametresinin 8MHz olduğundan emin olmalıyız. Bu ayardan sonra ise program kodlarını yazmaya geçebiliriz. İlk olarak kit üzerindeki LED’leri yakmak için gerekli ayarlamaların yapıldığı fonksiyonu inceleyelim;

1.LED Yak – Söndür Uygulaması

void GPIO_Setup(void)
{
/* GPIOD Clocku aktif hale getiriliyor... */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* PD12,PD13,PD14 ve PD15 çıkış olarak ayarlanıyor. GPIO Bus hızı 100 MHz...  */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
Aşağıdaki fonksiyon ise GPIO üzerinde belirttiğiniz pini set ediyor. Yani LED’i yakıyor.

GPIO_SetBits(GPIOD, GPIO_Pin_15);

Aşağıdaki fonksiyon ise GPIO üzerinde belirttiğiniz pini set ediyor. Yani LED’i söndürüyor.

GPIO_ResetBits(GPIOD, GPIO_Pin_15);

Bu kısım için bir örnek verelim.

/* STM32F4 Led Yak - Söndür Programı
   Kit üzerindeki LD15'i(mavi) yakıp söndüren program...
*/

#include "stm32f4_discovery.h"

GPIO_InitTypeDef    GPIO_InitStructure;

void Delay(__IO uint32_t nCount);
void GPIO_Setup(void);
int main(void)
{

  GPIO_Setup();

  while (1)
  {
    GPIO_SetBits(GPIOD, GPIO_Pin_15);
    Delay(0x3FFFFF);

    GPIO_ResetBits(GPIOD, GPIO_Pin_15);
    Delay(0x3FFFFF);
  }
}

void Delay(__IO uint32_t nCount)
{
  while(nCount--);
}

void GPIO_Setup(void)
{
  /* GPIOD Clocku aktif hale getiriliyor... */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  /* PD12,PD13,PD14 ve PD15 çıkış olarak ayarlanıyor. GPIO Bus hızı 100 MHz...  */
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
}
Yukarıda verdiğim program önce GPIO ların clock kaynağını aktif hale getiriyor ve ardından LED’lerin bağlı olduğu pinleri çıkış yapıyor(GPIO_Setup fonksiyonu). Sonrasında ise ana program içerisinde bu fonskiyon bir kez çağrıldıktan sonra sonsuz döngü içerisinde LED15 yanıp sönüyor.
GPIO’lar hakkında daha geniş bir bilgiye aşağıdaki bağlantıdan ulaşabilirsiniz.

 

2.Buton Okuma Uygulaması

Aşağıdaki programda ise STM32F4 kiti üzerindeki USER_BUTTON‘u durumu okunup, eğer basıldı ise LED15 yanıyor, bırakıldı ise LED15 sönüyor.

/* STM32F4 buton okuma Programı
     Kit üzerindeki USER_BUTTON basılı ise LD15'i(mavi) yakan
     Basılı değilse LED'i söndüren program...
*/

#include "stm32f4_discovery.h"
GPIO_InitTypeDef GPIO_InitStructure;
void Delay(__IO uint32_t nCount);
 void GPIO_Setup(void);
int main(void)
{

  while (1)
  {
     if(STM_EVAL_PBGetState(BUTTON_USER)) == 1)
        GPIO_SetBits(GPIOD, GPIO_Pin_15);
     else
        GPIO_ResetBits(GPIOD, GPIO_Pin_15);
  }
}

void GPIO_Setup(void)
{
  /* GPIOD Clocku aktif hale getiriliyor... */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  /* PD12,PD13,PD14 ve PD15 çıkış olarak ayarlanıyor. GPIO Bus hızı 100 MHz...  */
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &GPIO_InitStructure);

  STM_EVAL_PBInit(BUTTON_USER,BUTTON_MODE_GPIO);
}

Buradaki GPIO_Setup fonksiyonuna ekstra olarak şu satırı da ekledik.

STM_EVAL_PBInit(BUTTON_USER,BUTTON_MODE_GPIO);

Bu fonksiyon ile kit üzerindeki butonun GPIO girişi olarak kullanılacağını belirtiyoruz.

3. TIM3 ile 4 Kanal PWM Uygulaması

Bu uygulamada ise bir adet Timer kullnarak 4 kanal PWM üreteceğiz.
Timer’lar hakkında bilgi edinmek için User’s Manual‘i inceleyebilirsiniz(sayfa 361).
STM32F407 mikrodenetleyicisinde yukarıda da belirtildiği gibi 17 adete kadar timer bulunabiliyor.
Bunlardan bizim kullanacağımız TIM3 Timer’ını inceleyecek olursak;
  • 16 bit up,down ve up/down modda çalışabilme
  • 16 bit prescaler(frekans bölücü)
  • Birbirinden bağımsız 4 farklı mod
    • Input Capture
    • Output Compare
    • PWM Output
    • One-Pulse Mode Output
  • Kesme / DMA Deseği
  • Quadrator Encoder Desteği
TIM3 birimi genel olarak bu özelliklere sahip. Biz bu uygulamada CCR Registerlerini kullanarak PC6,PC7,PB0,PB1 pinlerinden aynı frekansta fakat farklı doluluk(duty) oranlarında 4 farklı çıkış üreteceğiz.
  • 1.Kanal(PC6) -> %50
  • 2.Kanal(PC7) -> %37.5
  • 3.Kanal(PB0) ->%25
  • 4.Kanal(PB1) -> %12.5
Doluluk oranı aşağıdaki formülden hesaplanıyor.
TIM3_ARR = 665

duty cycle = (TIM3_CCR1/ TIM3_ARR)* 100

 

Aşağıdaki uygulama PB0,PB1,PC6,PC7 pinlerinden 4 farklı doluluk oranında PWM üretmekte ve Kit üzerindeki mavi butona basıldığında LED12,13.14,15 i sırası ile yakmakta ve sırası ile söndürmektedir.

/* STM32F4 ile 4 Kanal PWM Uygulaması
    www.fatihinanc.com
    21.11.2011
*/


#include "stm32f4_discovery.h"

void Delay(__IO uint32_t nCount);
void GPIO_Setup(void);
void GPIO_Toggle(void);
void Button_Test(void);
void TIM_Config(void);
void PWM_Setup(void);

char durum;

TIM_TimeBaseInitTypeDef     TIM_TimeBaseStructure;
TIM_OCInitTypeDef           TIM_OCInitStructure;
uint16_t CCR1_Val = 333;
uint16_t CCR2_Val = 249;
uint16_t CCR3_Val = 166;
uint16_t CCR4_Val = 83;
uint16_t PrescalerValue = 0;

int main(void)
{
  TIM_Config();
  PWM_Setup();
  GPIO_Setup();

  while (1)
  {
    Button_Test();
    if(durum == 1)
        GPIO_Toggle();
  }
}

void Delay(__IO uint32_t nCount)
{
  while(nCount--);
}
void GPIO_Toggle(void)
{
    //Set
    GPIO_SetBits(GPIOD, GPIO_Pin_12);
    Delay(0x3FFFFF);

    GPIO_SetBits(GPIOD, GPIO_Pin_13);
    Delay(0x3FFFFF);

    GPIO_SetBits(GPIOD, GPIO_Pin_14);
    Delay(0x3FFFFF);

    GPIO_SetBits(GPIOD, GPIO_Pin_15);
    Delay(0x3FFFFF);

    //Reset
    GPIO_ResetBits(GPIOD, GPIO_Pin_15);
    Delay(0x3FFFFF);

    GPIO_ResetBits(GPIOD, GPIO_Pin_14);
    Delay(0x3FFFFF);

    GPIO_ResetBits(GPIOD, GPIO_Pin_13);
    Delay(0x3FFFFF);

    GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    Delay(0x3FFFFF);

    //GPIO_ResetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);
    //Delay(0xFFFFFF);
}

void Button_Test(void)
{
    if(STM_EVAL_PBGetState(BUTTON_USER))
        durum = 1;
    else
        durum = 0;
}
void GPIO_Setup(void)
{
  /* GPIOD Periph clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  /* Configure PD12, PD13, PD14 and PD15 in output pushpull mode */
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &GPIO_InitStructure);

  STM_EVAL_PBInit(BUTTON_USER,BUTTON_MODE_GPIO);
}

void TIM_Config(void)
{
/* -----------------------------------------------------------------------
    TIM3 Configuration: generate 4 PWM signals with 4 different duty cycles.

    In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),
    since APB1 prescaler is different from 1.
      TIM3CLK = 2 * PCLK1
      PCLK1 = HCLK / 4
      => TIM3CLK = HCLK / 2 = SystemCoreClock /2

    To get TIM3 counter clock at 28 MHz, the prescaler is computed as follows:
       Prescaler = (TIM3CLK / TIM3 counter clock) - 1
       Prescaler = ((SystemCoreClock /2) /28 MHz) - 1

    To get TIM3 output clock at 30 KHz, the period (ARR)) is computed as follows:
       ARR = (TIM3 counter clock / TIM3 output clock) - 1
           = 665

    TIM3 Channel1 duty cycle = (TIM3_CCR1/ TIM3_ARR)* 100 = 50%
    TIM3 Channel2 duty cycle = (TIM3_CCR2/ TIM3_ARR)* 100 = 37.5%
    TIM3 Channel3 duty cycle = (TIM3_CCR3/ TIM3_ARR)* 100 = 25%
    TIM3 Channel4 duty cycle = (TIM3_CCR4/ TIM3_ARR)* 100 = 12.5%

    Note:
     SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
     Each time the core clock (HCLK) changes, user had to call SystemCoreClockUpdate()
     function to update SystemCoreClock variable value. Otherwise, any configuration
     based on this variable will be incorrect.
  ----------------------------------------------------------------------- */


  GPIO_InitTypeDef GPIO_InitStructure;

  /* TIM3 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  /* GPIOC and GPIOB clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOB, ENABLE);

  /* GPIOC Configuration: TIM3 CH1 (PC6) and TIM3 CH2 (PC7) */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 ;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

  /* GPIOB Configuration:  TIM3 CH3 (PB0) and TIM3 CH4 (PB1) */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  /* Connect TIM3 pins to AF2 */
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource0, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource1, GPIO_AF_TIM3);
}

void PWM_Setup(void)
{
    /* Compute the prescaler value */
  PrescalerValue = (uint16_t) ((SystemCoreClock /2) / 28000000) - 1;

  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 665;
  TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  /* PWM1 Mode configuration: Channel1 */
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

  TIM_OC1Init(TIM3, &TIM_OCInitStructure);

  TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);

  /* PWM1 Mode configuration: Channel2 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR2_Val;

  TIM_OC2Init(TIM3, &TIM_OCInitStructure);

  TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);

  /* PWM1 Mode configuration: Channel3 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR3_Val;

  TIM_OC3Init(TIM3, &TIM_OCInitStructure);

  TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);

  /* PWM1 Mode configuration: Channel4 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR4_Val;

  TIM_OC4Init(TIM3, &TIM_OCInitStructure);

  TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);

  TIM_ARRPreloadConfig(TIM3, ENABLE);

  /* TIM3 enable counter */
  TIM_Cmd(TIM3, ENABLE);
}

 

Yazımı bitirmenden önce STM32F4 Discovery Kiti hakkında Türkçe olarak daha geniş bilgiler ve örnek uyulamalar bulabileceğiniz birkaç bağlantı vereceğim.

Keil programının kurulumu ve kullanılması

STM32F407 – Terimler

STM32F407VG – STM32F4 Discovery Deneme Kartı

STM32F-Discovery örnek temel programlar

www.picproje.org sitesindeki bu notları hazırladığı için Bülent ÜNALMIŞ hocamıza teşekkürü borç bilirim.

Referans : http://www.cncdesigner.com/STM/Baglanti.JPG