MIKRO_UTB

/*
 * Ukazkovy program pro Programovani mikropocitacu
 * Casovac TPM, generovani PWM.
 * Program ukazuje rizeni jasu LED s vyuzitim casovace.
 * Cervena LED na FRDM-KL25Z meni jas od 0 do 100% pomoci hardwarove
 * generovaneho PWM casovacem TPM2 s frekvenci 100 Hz.
 *
 * POZOR: v nastaveni projektu > compiler > preprocesor musi byt CLOCK_SETUP=1
 * aby byl CPU clock 48 MHz!
 *
 * Uzitecne informace:
 * Pomoci casovace muzeme ridit LED RGB primo na FRDM-KL25Z desce,
 * LED LD1 az LD3 na vyvojovem kitu nejsou napojeny na kanaly casovace.
 *
 * B18  - Red LED - TPM2 kanal 0 (ALT3)
 * B19  - Green LED - TPM2 kanal 1 (ALT3)
 * D1   - Blue LED - TPM0 kanal 1 (ALT4)
 *
 */

#include "MKL25Z4.h"
#include "stdbool.h"
#include <stdio.h>
#include "drv_gpio.h"
#include "drv_lcd.h"

// Cislo kanalu TPM2 na kterem generujeme PWM
// 0 - RED LED
// 1 - GREEN LED
#define PWM_CHANNEL     (0)

#define SWITCH_PRESSED      (1)
#define SWITCH_NOT_PRESSED  (0)


// Cislo pinu, na kterem generujeme PWM
// POZOR: musi byt synchronni s PWM_CHANNEL!
#define PWM_PINNUMBER   (18)

void delay(void);
int switch1_read(void);
int switch2_read(void);
int switch3_read(void);
void delay_debounce(void);

int main(void)
{
    //Tlacitka
    // inicializace pinu pro tlacitko
    pinMode(SW1, INPUT_PULLUP);
    pinMode(SW2, INPUT_PULLUP);
    pinMode(SW3, INPUT_PULLUP);


    int sw_state1;
    int sw_state2;
    int sw_state3;

    // inicializace ovladace GPIO
    GPIO_Initialize();

    //LCD
    LCD_initialize();
    LCD_clear();






    // Kolik tiku casovace odpovida 1% sirky pulsu.
    // Nastaveno na spravnou hodnotu nize pri nastaveni casovace
    uint32_t ticksPerPercent = 1;


    // Povolit clock pro TPM0, tpm2
    SIM->SCGC6 |= SIM_SCGC6_TPM2_MASK;


    // Nastavit zdroj hodin pro casovac TPM (sdileno vsemi moduly TPM)
    // Dostupne zdroje hodinoveho signalu zavisi na CLOCK_SETUP
    // Pro CLOCK_SETUP = 1 nebo 4 je mozno pouzit OSCERCLK (8 MHz)
    // Pro CLOCK_SETUP = 0 (vychozi v novem projektu) PLLFLLCLK (20.97152 MHz)
    // Mozne hodnoty:
    // 0 - clock vypnut
    // 1 - MCGFLLCLK nebo MCGFLLCLK/2
    // 2 - OSCERCLK
    // 3 - MCGIRCLK  (interni generator, 32 kHz nebo 4 MHz)
    // !!! Pozor pri zapisu do SOPT2 nespolehat na to, ze oba bity
    // pole TPMSRC jsou vynulovany, nestaci SOPT2[TPMSRC] |= nova_hodnota;
    // je nutno nejprve vynulovat a pak "ORovat" novou hodnotu.
    SIM->SOPT2 &= ~SIM_SOPT2_TPMSRC_MASK;
    SIM->SOPT2 |= SIM_SOPT2_TPMSRC(2);


    // Nastavit casovac
    // Pole PS (prescale) muze byt zmeneno pouze, kdyz je
    // citac casovace zakazan (counter disabled), tj. pokud SC[CMOD] = 0
    // ...nejprve zakazat counter
    TPM2->SC = TPM_SC_CMOD(0);

    // ...pockat az se zmena projevi (acknowledged in the LPTPM clock domain)
    while (TPM2->SC & TPM_SC_CMOD_MASK )
        ;

    //
    // ... pri zakazanem citaci provest nastaveni
    //
    // Nastavime PWM s pulsy zarovnanymi na zacatek periody (edge aligned).
    // Protoze LED sviti pri log. 0 na pinu, pouzijeme low-true pulses,
    // tj. puls bude hodnota log. 0 a "klid" mezi pulsy bude log. 1.
    // Doba do preteceni citace urcuje periodu PWM.
    // Pozadujeme periodu 100 Hz, tedy doba do preteceni je 0.01 s (10 ms):
    // Modulo = (0.01 * 8000000)/Prescale = 80000/8 = 10000
    // Modulo bude 10 000, coz je 100% sirky pulsu (perioda PWM)
    // Tedy 1% = 100 "tiku" casovace.
    TPM2->CNT = 0;  // manual doporucuje vynulovat citac pred zapisem modulo
    TPM2->MOD = 10000;

    // Nastavime kolik je tiku casovace na 1% sirky pulsu pro lepsi
    // citelnost zbytku programu
    ticksPerPercent = 100;

    // Nastavit rezim casovace na PWM edge aligned, low true pulses
    TPM2->CONTROLS[PWM_CHANNEL].CnSC = (TPM_CnSC_MSB_MASK | TPM_CnSC_ELSA_MASK);

    // Nastavit pin na PWM vystup
    // ... povolit hodinovy signal pro port pinu
    SIM->SCGC5 |=  SIM_SCGC5_PORTB_MASK;
    SIM->SCGC5 |=  SIM_SCGC5_PORTD_MASK;

    // ...Kanal casovace je funkce pinu 3 (ALT3)
    PORTB->PCR[PWM_PINNUMBER] = PORT_PCR_MUX(3);
    PORTD->PCR[PWM_PINNUMBER] = PORT_PCR_MUX(3);



    // Zapiseme pocatecni hodnotu duty, napr. na 10%
    //0% pro ukol navic
    TPM2->CONTROLS[PWM_CHANNEL].CnV = 0 * ticksPerPercent;
    TPM0->CONTROLS[PWM_CHANNEL].CnV = 0 * ticksPerPercent;



    // Nastavime casovac a spustime citani zapisem nenulove delicky (prescale)
    // TPM_SC_PS(3): 3 je hodnota pole PS pro nastaveni delicky na 8
    TPM2->SC = ( TPM_SC_CMOD(1) | TPM_SC_PS(3) );
    TPM0->SC = ( TPM_SC_CMOD(1) | TPM_SC_PS(3) );



    // Budeme plynule menit duty od 0 do 100%
    uint32_t dutyInPercent1 = 0;
    uint32_t dutyInPercent2 = 0;
    uint32_t dutyInPercent3 = 0;


    //bool directionUp = true;
    while(1)
    {
        /* Zapis nove sirky pulsu do registru casovace
        TPM2->CONTROLS[PWM_CHANNEL].CnV = dutyInPercent1 * ticksPerPercent;
        TPM2->CONTROLS[PWM_CHANNEL1].CnV = dutyInPercent2 * ticksPerPercent;
        TPM0->CONTROLS[PWM_CHANNEL2].CnV = dutyInPercent3 * ticksPerPercent;
char str[10];
if ( sw_state1 == SWITCH_PRESSED) {,
pinMode(LED_RED,OUTPUT);
dutyInPercent1+=10;
    sprintf(str, "%d", dutyInPercent1);
    LCD_set_cursor(1,1);
    LCD_puts(str);
    if ( dutyInPercent1 == 100 ) {
        dutyInPercent1 = 0;
    }
}
if ( sw_state2 == SWITCH_PRESSED) {
pinMode(LED_GREEN,OUTPUT);
dutyInPercent2+=10;
sprintf(str, "%d", dutyInPercent2);
LCD_set_cursor(2,1);
LCD_puts(str);

        if ( dutyInPercent2 == 100 ) {
            dutyInPercent2 = 0;
        }
}
if ( ( sw_state3 == SWITCH_PRESSED) {,                      dutyInPercent3+=10;
sprintf(str, "%d", dutyInPercent3);
LCD_set_cursor(3,1);

LCD_puts(str);
        if ( dutyInPercent3 == 100 ) {
            dutyInPercent3 = 0;
        }
delay();
}               }
            else
            dutyInPercent==0;
        }


        delay();

    }

    /* Never leave main */
    return 0;}
/* delay
 Jednoducha cekaci funkce - busy wait
*/
void delay(void)
{
    unsigned long n = 1000000L;
    while ( n-- )
        ;
}


int switch1_read(void)
{
    int switch_state1 = SWITCH_NOT_PRESSED;
    if ( pinRead(SW1) == LOW )
    {
        // tlacitko je stisknuto

        // debounce = wait
        unsigned long n = 200000L;
            while ( n-- )
                ;

        // znovu zkontrolovat stav tlacitka
        if ( pinRead(SW1) == LOW )
        {
            switch_state1 = SWITCH_PRESSED;
        }
    }
    // vratime stav tlacitka
    return switch_state1;
}

int switch2_read(void)
{
    int switch_state2 = SWITCH_NOT_PRESSED;
    if ( pinRead(SW2) == LOW )
    {
        // tlacitko je stisknuto

        // debounce = wait
        unsigned long n = 200000L;
            while ( n-- )
                ;

        // znovu zkontrolovat stav tlacitka
        if ( pinRead(SW2) == LOW )
        {
            switch_state2 = SWITCH_PRESSED;
        }
    }
    // vratime stav tlacitka
    return switch_state2;
}
int switch3_read(void)
{
    int switch_state3 = SWITCH_NOT_PRESSED;
    if ( pinRead(SW3) == LOW )
    {
        // tlacitko je stisknuto

        // debounce = wait
        unsigned long n = 200000L;
            while ( n-- )
                ;

        // znovu zkontrolovat stav tlacitka
        if ( pinRead(SW3) == LOW )
        {
            switch_state3 = SWITCH_PRESSED;
        }
    }
    // vratime stav tlacitka
    return switch_state2;
}





////////////////////////////////////////////////////////////////////////////////
// EOF
////////////////////////////////////////////////////////////////////////////////