[RSDMK] Poceo 4. UART

#include <c8051f340.h>
#include "time.h"
#include "uart.h"

// znojimo preprocesor
#define cekaj_prijem()          while(!UART0_Available())
#define primljen_karakter()     UART0_Available() > 0

//#define CURIOUS_MODE

char strLen(char *str);
char* intToStr(int num, char *digits);

char* intToHex(int num, char *digits);
int strToInt(char *str);
int pow(int sta, char na_sta);

 /*
  * Niz u kome se cuvaju cifre brojeva koji se konvertuju
  * u sringove kako bi se mogli ispisivati.
  */
char cifre[8];

// enable flag za ispis uvodne poruke
bit ispisano = 0;

int i = 0;

char prijem[64];

void OSCILLATOR_Init (void);
void PORT_Init (void);

void main(void)
{
    OSCILLATOR_Init();  // Inicijalizacija oscilatora (Fosc = 22.1184 MHz)
    TIME_Init();        // Inicijalizacija sistemskog vremena (koristi se prekid tajmera 2)
    PORT_Init();        // Inicijalizacija portova

    UART0_Init();

    while (1)
    {
        if(!ispisano) {
            UART0_PutString("Unesite tekst za provjeru: \n");
            ispisano = 1;
        }

        cekaj_prijem();

        if(primljen_karakter()) {
            delay_ms(100);
            UART0_GetString(prijem);
        }

        intToStr(strToInt(prijem), cifre);
        //intToStr(1000, cifre);
        UART0_PutString("\nUneseni broj kao string: ");
        UART0_PutString(cifre);
        UART0_PutString("\n\n");
        UART0_PutString("\n\n");


        /*UART0_PutString("Unijeli ste: ");
        UART0_PutString(prijem);
        UART0_PutString("\n");

        UART0_PutString("Duzina unosa je: ");
        // + 0 vrsi konverziju char tipa u integer.
        UART0_PutString(intToStr(strLen(prijem) + 0, cifre));
        UART0_PutString("\n\n"); */

        //intToHex(1000, cifre);
        UART0_PutString("\nUnijeli ste ");
        UART0_PutString(prijem);
        UART0_PutString(" = 0x");

        //intToHex(strToInt(prijem), cifre);
        intToHex(1000, cifre);
        UART0_PutString(cifre);
        UART0_PutString("\n\n");


    /*  UART0_PutString("\nDuzina stringa intToStr(1000, cifre) : ");
        UART0_PutString(intToStr(strLen(intToStr(1000, cifre)) + 0, cifre));
        UART0_PutString("\n\n");  */


        /*
        // pretvaram broj string cifara kako bih ga ispisao.
        intToStr(12345, cifre);

        UART0_PutString("Uneseni broj kao string: ");
        UART0_PutString(cifre);
        UART0_PutString("\n\n");  */

        /* --- */

        /* --- */

        // dozvoli ponovni ispis pocetne poruke
        ispisano = 0;

    }
 }

/*
 * Vraca duzinu stringa. You dont say?
 */
char strLen(char *str) {
    char len = 0;
    while(*str) {
        len++;
        str++;
    }
    // Ovaj -1 je kompenzacija za '\0' character
    //return len - 1;
    return len;
}

/*
 * Nisam probavao math.h, cak i ako ima njen pow je slozeniji
 * jer mozes stpenovati i sa realnim brojem, meni treba jednostavno
 * stepenovanje cijelim brojem.
 */
int pow(int sta, char na_sta) {
    char i = 0;
    int rezultat = 1;

    for(i = 0; i < na_sta; i++) {
        rezultat *= sta;
    }

    return rezultat;
}

/*
 * Konverzija stringa u integer broj.
 * Potrebno iz razloga sto podatke koje primis preko UARTA,
 * program vidi kao ASCII karaktere koji mu nemaju nikakvo znacenje
 * ne zna sta je 2367 nego zna sta su 2, 3, 6, 7
 */
int strToInt(char *str) {
    char duzina = strLen(str);

    int rezultat = 0;
    char i = 0;

    /*for(i = 0; i < duzina; i++) {
        rezultat += ((*(str+i))+0) * pow(10, (duzina-i-1)+0);
    } */
    rezultat += *(str+0) * 100;
    rezultat += *(str+1) * 10;
    rezultat += *(str+2) * 1;

    /*rezultat += 2 * 100;
    rezultat += 3 * 10;
    rezultat += 4 * 1; */

    return rezultat;
}

/*
 * Konverzija proizvoljnog integera u hex zapis.
 */
char* intToHex(int num, char *digits) {
    // broj cifara
    char digitCnt   = 0;
    // pomocna cifra
    char digitTmp;

    int ostatak;

    char i = 0;

    while(num) {
        // +'0' prisiljava konverziju integera u char,
        // kastovanje iz nekog razloga ne radi.
        ostatak = (num % 16);
        num = num / 16;

        switch(ostatak) {
            /*
             * U krstenom kompajleru i alatu ovo radi. Stop. Keilu.
                case 0 ... 9:
                    digitTmp = digitTmp;            // zadrzava svoju vrijednost
                break;
            *
            */

            /*
             * Al bi bilo fantasticno da ovo mozeeeeee...
                for(i = 0; i < 10; i++) {
                    case i: digitTmp = i + '0'; break;
                }
            */


            /*
             * Mozeo ovako sljakerski...
            case 0: digitTmp = '0'; break;
            case 1: digitTmp = '1'; break;
            case 2: digitTmp = '2'; break;
            case 3: digitTmp = '3'; break;
            case 4: digitTmp = '4'; break;
            case 5: digitTmp = '5'; break;
            case 6: digitTmp = '6'; break;
            case 7: digitTmp = '7'; break;
            case 8: digitTmp = '8'; break;
            case 9: digitTmp = '9'; break; */
            case 10: digitTmp = 'A'; break;
            case 11: digitTmp = 'B'; break;
            case 12: digitTmp = 'C'; break;
            case 13: digitTmp = 'D'; break;
            case 14: digitTmp = 'E'; break;
            case 15: digitTmp = 'F'; break;

            // najelegantnije od svih preostalih koji rade.
            default:
                digitTmp = ostatak + '0';
            break;
        }

        /*
         * Za one koji zele da vide kako radi ovaj while(num)
         * Ispisuje jednu po jednu cifru... Radice dobro samo ako se
         * koristi van neke druge funkcije, pozoves samu negdje npr.
         */
        #ifdef CURIOUS_MODE
            UART0_PutString("Cifra: ");
            UART0_PutChar(digitTmp);
            UART0_PutChar('\n');
            delay_ms(500);
        #endif

        *(digits+digitCnt) = digitTmp;
        digitCnt++;
    }

    // u ovom trenutku imamo sve cifre, ali naopako poslagane. Obrcem.
    for(i = 0; i < digitCnt / 2; i++) {
                                                    // komentari za prvi prolaz petlje:
        digitTmp = *(digits+i);                     // uzmem prvu cifru niza
        /*
         * -1 postoji da se odmaknem korak nazad
         * od terminacionog karaktera
         */
        *(digits+i) = *(digits+digitCnt-1-i);       // na prvu stavim poslednju
        *(digits+digitCnt-1-i) = digitTmp;          // na poslednju stavim prvu
                                                    // i proces se ponavlja sa 2. i n-1, sa 3. i n-2 cifrom itd.
    }
    // pravim string, dodajem terminacioni karakter na kraj.
    *(digits+digitCnt) = '\0';
    return digits;
}

/*
 * Integer proizvoljne duzine prebacuje u string.
 * Nije trazeno u zadatku, ali sto da ne.
 * Sto da ne? Sto da ne kolega...
 */
char* intToStr(int num, char *digits) {
    // broj cifara
    char digitCnt   = 0;
    // pomocna cifra
    char digitTmp;

    char i = 0;

    while(num) {
        // +'0' prisiljava konverziju integera u char,
        // kastovanje iz nekog razloga ne radi.
        digitTmp = (num % 10)+'0';
        num = num / 10;

        /*
         * Za one koji zele da vide kako radi ovaj while(num)
         * Ispisuje jednu po jednu cifru... Radice dobro samo ako se
         * koristi van neke druge funkcije, pozoves samu negdje npr.
         */
        #ifdef CURIOUS_MODE
            UART0_PutString("Cifra: ");
            UART0_PutChar(digitTmp);
            UART0_PutChar('\n');
            delay_ms(500);
        #endif

        *(digits+digitCnt) = digitTmp;
        digitCnt++;
    }

    // u ovom trenutku imamo sve cifre, ali naopako poslagane. Obrcem.
    for(i = 0; i < digitCnt / 2; i++) {
                                                    // komentari za prvi prolaz petlje:
        digitTmp = *(digits+i);                     // uzmem prvu cifru niza
        /*
         * -1 postoji da se odmaknem korak nazad
         * od terminacionog karaktera
         */
        *(digits+i) = *(digits+digitCnt-1-i);       // na prvu stavim poslednju
        *(digits+digitCnt-1-i) = digitTmp;          // na poslednju stavim prvu
                                                    // i proces se ponavlja sa 2. i n-1, sa 3. i n-2 cifrom itd.
    }
    // pravim string, dodajem terminacioni karakter na kraj.
    *(digits+digitCnt) = '\0';
    return digits;
}


void PORT_Init (void)
{
   //P2MDIN |= 0x0F;                // 4 najniza bita porta P2 -> digitalni
   //P2MDOUT = 0x0C;                // Pinovi za LED -> push-pull izlazi

   // Crossbar inicijalizacija
   //XBR1    = 0x40;                // Dozvola crossbar-a i slabih pull-up otpornika
}