STM32F4 Inicijalizacija - startup code

Code:
//******************************************//
//               LED  on/off                //
//******************************************//


#include "system_stm32f4xx.c"
#include "stdio.h"


//------------------------------------------------------------------
// Funkcija 'pauza_ms(x)' je kalibrisana za SYSCLK 168MHz i otuda 'i=33333'
// Za sporije jezgro smanjiti vrednost 'i'
void pauza_ms(vu32 wtf)
{
    vu16 i;
    while(wtf--)
    {
        for(i=33333;i>0;i--);
    }
}


//-----------------------------------------------------------------------
// Funcija 'LED_on(x)' ukljucuje LED_1 | LED_2 | LED_3 ili LED_4, gde je 
// 'x' broj LEDiode, ako je vrednost 'x' nula onda se ukjucuju sve cetiri 

void LED_on(u8 led_sw)
{
     switch(led_sw)
    {
         case 0:
            GPIO_SetBits(GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        break;

         case 1:
            GPIO_SetBits(GPIOD, GPIO_Pin_12);
        break;

         case 2:
            GPIO_SetBits(GPIOD, GPIO_Pin_13);
        break;

         case 3:
            GPIO_SetBits(GPIOD, GPIO_Pin_14);
        break;

         case 4:
            GPIO_SetBits(GPIOD, GPIO_Pin_15);
        break;


        default:
        break;
    }
}

//------------------------------------------------------------------------
// Funcija 'LED_off(x)' iskljucuje LED_1 | LED_2 | LED_3 ili LED_4, gde je 
// 'x' broj LEDiode, ako je vrednost 'x' nula onda se iskjucuju sve cetiri 

void LED_off(u8 led_sw)
{
     switch(led_sw)
    {
         case 0:
            GPIO_ResetBits(GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        break;

         case 1:
            GPIO_ResetBits(GPIOD, GPIO_Pin_12);
        break;

         case 2:
            GPIO_ResetBits(GPIOD, GPIO_Pin_13);
        break;

         case 3:
            GPIO_ResetBits(GPIOD, GPIO_Pin_14);
        break;

         case 4:
            GPIO_ResetBits(GPIOD, GPIO_Pin_15);
        break;


        default:
        break;
    }
}

//-------------------------------------------------------
// Konfigurisanje LED-ova...

void LED_Config()
{
     // Prvo nam treba struktura GPIO_InitTypeDef
     // Ta struktura sadrzi podatke za setovanje
     // GPIO perfierije na ARM-u

     // Deklaracija promenjljive GPIO tipa GPIO_InitTypeDef
    GPIO_InitTypeDef GPIO;

     // Svaki zaseban "deo" samog mikrokontrolera moze da se
     // upali / ugasi. Po default-u svi su ugaseni. Da bi
     // upalio neki "delo/periferiju" treba da ukljucis
     // njegov klok. Ovde sada palimo klok za port D.
     // Obratite paznju da ako neki deo nema klok on ne trosi
     // struju (zato su po defaultu svi ugaseni. Ako preskocimo
     // ovu liniju, sve ce "delovati" da radi, ali fizicki
     // sam port ce biti ugasen te u realnosti nikakvi signali
     // na tom portu nece napustiti mcu
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

     // Sada setujemo samo pinove na portu D da budu izlazni
     // to radimo tako sto prvo popunimo GPIO_InitTypeDef strukturu
     // i prosledimo je GPIO_Init funkciji.
     // u varijabli GPIO_Pin GPIO_InitTypeDef strukture definisemo masku
     // za pinove kojima hocemo da modifikujemo status
    GPIO.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;

     // u varijabli GPIO_Mode GPIO_InitTypeDef strukture definisemo
     // SMER
     // GPIO_Mode_OUT je izlaz
     // GPIO_Mode_IN je ulaz,
     // GPIO_Mode_AF je "alternate function" (UART, SPI ..)
     // GPIO_Mode_AIN je analogni ulaz
     // GPIO_Mode_AN je analogni izlaz

     // postoje (ne na ovom mcu-u) jos _in_floating za floating input,
     // _ipd za input + pull down, _ipu za input + pull up,
     // _out_od za output koji je open drain,
     // _af_od za alternate function + open dran ..i verovatno jos neki
     // koje ja nikad nisam koristio, zavisi od mcu-a do mcu-a
     // sve zavisi, dakle na nekim mcu-ima se tip izlaza definise
     // ovde, na ovom se definise kroz OType
    GPIO.GPIO_Mode=GPIO_Mode_OUT;

     // u varijabli GPIO_Otype GPIO_InitTypeDef strukture definisemo
     // kog je tipa output. Na SMT32F4 se to definise kroz ovu varijablu
     // a ne kroz GPIO_Mode kao na STM32F1 na primer.
     // GPIO_OType_PP je PushPull izlaz (standardan)
     // GPIO_OType_OD je Open Drain izlaz
     // na ovom mcu-u nema trece vrste,
    GPIO.GPIO_OType=GPIO_OType_PP;

     // u varijabli GPIO_PuPd GPIO_InitTypeDef strukture definisemo
     // push up / pull down na ovom pinu
     // mogucnosti su _NOPULL za jeli "blanko", _UP i _DOWN za push up
     // u pull down
    GPIO.GPIO_PuPd=GPIO_PuPd_NOPULL;

     // u varijabli GPIO_Speed GPIO_InitTypeDef strukture definisemo
     // obratiti paznju da se ovo uvek odnosi na CEO PORT ne samo na
     // odabrane pinove. Ovo definise brzinu na kojoj GPIO port prica
     // sa jezgrom. Zavisno od frekvencije na kojoj radite i od mcu-a
     // sa kojim radite ima raznih brzina. 50MHz je safe na skoro svim
     // ARM procesorima, neki dozvoljavaju i vise (STM32F4 na discovery
     // plocki radi na 100MHz ok.
     // obratite paznju da veci takt znaci i veca potrosnja struje, ako
     // ce port da pali i gasi ledaru jedno u sekundi 2MHz je vise nego
     // dovoljno za frekvenciju gpio magistrale za taj port
    GPIO.GPIO_Speed=GPIO_Speed_2MHz;

     // i finalno pozovemo GPIO_Init i prosledimo port koji hocemo da
     // setujemo i pointer na strukturu koju smo upravo napravili
    GPIO_Init(GPIOD, &GPIO);    
}







//-------------------------------------------------------
// Pocetak 'glavnog programa'...

int main(void)
{
    LED_Config();
    
    while(1)
    {
        u8 u,i;
        for(i=10;i>0;i--)
         {
            for(u=4;u>0;u--)
            {
                LED_on(u);
                pauza_ms(20);
                LED_off(u);
                pauza_ms(15);
            }        
        }

        LED_on(0);
        for(i=8;i>0;i--)
        {
            LED_off(4);
            pauza_ms(50);

            LED_off(1);
            LED_on(4);
            pauza_ms(50);

            LED_off(2);
            LED_on(1);
            pauza_ms(50);

            LED_off(3);
            LED_on(2);
            pauza_ms(50);

//            LED_off(4);
            LED_on(3);
        }

        LED_off(0);

    }     
}

Code:

GPIO_TypeDef struktura;

struktura.nesto = x;
struktura.nestodrugo = y;
...

GPIO_Init(&struktura .. 

Code:

GPIO_TypeDef * pointernastrukturu;

//e sad posto pointer na strukturu ne kreira objekat u memoriji
// vec je samo pointer na memorisku lokaciju onda nam treba
// da kreiramo objekat, tj rezervisemo mesto za njega u ram-u

pointernastrukturu = (GPIO_TypeDef *) malloc( sizeof (GPIO_TypeDef) );

// dakle malloc je rezervisao onoliko bajtova koliko je velika 
// struktura GPIO_TypeDef i pointer na tu memorisku lokaciju
// ja smesten u nasu varijablu pointernastrukturu 


// obrati paznju da se sada clanovima strukture pristupa sa -> a ne sa .
// posto je pointernastrukturu pointer a ne struktura
pointernastrukturu->nesto = x;
pointernastrukturu->nestodrugo = y;
...

// i finalno mozemo da prosledimo taj pointer GPIO_Init funkciji
GPIO_Init(pointernastrukturu .. 

Code:

    GPIO_InitTypeDef GPIO;

    // definisemo 12-15 kao output
    GPIO.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
    GPIO.GPIO_Mode=GPIO_Mode_OUT;
    GPIO.GPIO_OType=GPIO_OType_PP;
    GPIO.GPIO_PuPd=GPIO_PuPd_NOPULL;
    GPIO.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_Init(GPIOD, &GPIO);    

    // definisemo 5 i 6 kao input
    // ostale clanove (npr speed) ne moramo da setujemo ponovo
    // posto su vec setovani malopre, posto koristimo istu varijablu
    GPIO.GPIO_Pin=GPIO_Pin_5|GPIO_Pin_6;
    GPIO.GPIO_Mode=GPIO_Mode_IN;
    GPIO_Init(GPIOD, &GPIO);    

Code:

Implementing Multiple Breakpoints with Atollic Lite
 
1. Create a software break function (in your main program) and set the single hardware breakpoint within.
 
void Break(int Number) {
    volatile int Temp;
    Temp = Number;  <------ set a single hardware breakpoint here!
}
 
 
2. Place a Function Prototype in any source file that will use the Break() function
// debug function to allow multiple breakpoints
void Break(int);
 
3.  Place the Break function before the line you wish to break.
     Increment the Break Number parameter each time you insert the Break() function.
 
    /* Start the scheduler. */
Break(1);
vTaskStartScheduler();
 
void vButtonLedtInitialise( void ) { GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
Break(2);
GPIO_Init( GPIOC, &GPIO_InitStructure );
 
4. Build the Program and run the Debugger. You will hardware break within the common Break() function as shown below.
    The Break number can be inspected by "hovering" the cursor over it.
    The "Step Out Of" command will place you at the desired line of code you wish to debug.
 
void Break(int Number)
{
volatile int Temp;
Temp = Number;    <---------- hardware will break here, current value of Number will help identify which source line caused the break.
}
 
Admittedly not as convenient as double-clicking on a source line to set a breakpoint, but it will get the job done.
 
Cheers,
Jim Lynch