[RSDMK] Tastatura 2. Kalkulator

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

#include <stdlib.h>
#include <string.h>

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

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

#define UNOS_MAX 8

char    Keypad_Scan();
void    pocupajOperande(char *unos, char operandi[2][UNOS_MAX], char *operator);
char*   intToStr(int num, char *digits);
int     racunaj();

char xdata  unos[UNOS_MAX];
char        unosBrojac = 0;
char        operator = 0;
bit         gotovUnos = 0;
char        operandi[2][UNOS_MAX];
char        rezultat[UNOS_MAX];
bit         ispisano = 0;

char        taster;
char        taster_prev;

void main(void)
{
    int i = 0;

    PCA0MD &= ~0x40;    // Watchdog tajmer iskljucen

    OSCILLATOR_Init();  // Inicijalizacija oscilatora (Fosc = 22.1184 MHz)
    TIME_Init();        // Inicijalizacija sistemskog vremena (koristi se prekid tajmera 2)
    PORT_Init();        // Inicijalizacija portova
    UART0_Init();       // startuje UART0

    while(1) {
        taster_prev = taster;
        taster = Keypad_Scan();

        if(taster && (!taster_prev)) {
            if(taster == '#') {
                // iza poslednjeg unesenog karaktera stavi terminacioni
                unos[unosBrojac] = '\0';
                gotovUnos = 1;
                unosBrojac = 0;
                ispisano = 0;           // dozvoli ponovo ispis dole
            } else {
                if(unosBrojac < UNOS_MAX){
                    unos[unosBrojac++] = taster;
                    UART0_PutChar(taster);
                }
            }
        }

        if(!ispisano && gotovUnos) {
            UART0_PutString("\nUnijeli ste: ");
            UART0_PutString(unos);

            pocupajOperande(unos, operandi, &operator);

            UART0_PutString("\n\nPrvi operand:  ");
            UART0_PutString(operandi[0]);

            UART0_PutString("\nOperator:    ");
            UART0_PutChar(operator);

            UART0_PutString("\nDrugi operand:   ");
            UART0_PutString(operandi[1]);
            // ------------------------------------------

            // ispis oblika kakav su trazili
            UART0_PutString("\n");
            UART0_PutString(operandi[0]);
            UART0_PutChar(operator);
            UART0_PutString(operandi[1]);
            UART0_PutChar('=');

            UART0_PutString(intToStr(racunaj(), rezultat));

            UART0_PutString("\n\n");

            ispisano = 1;
            gotovUnos = 0;
        }
    }
 }

/*
 * Okej, nije moralo ovako, ali sto da ne.
 *
 * Unos je oblika 123A234 , operatori su A, B, C, D
 *
 * JU! STA ZVEZDICA! Prosto sija...
 **/
void pocupajOperande(char *unos, char operandi[2][UNOS_MAX], char *operator) {
    // brojac koji prolazi kroz cijeli unos
    char i = 0;     // broji karaktere u prvom operandu I UKUPAN BROJ NJIH
    char j = 0;     // broji karaktere u drugom operandu
    while(
        *(unos+i) != 'A' &&
        *(unos+i) != 'B' &&
        *(unos+i) != 'C' &&
        *(unos+i) != 'D' &&
        *(unos+i) != '*' &&
        *(unos+i) != '#'
    ) {
        //UART0_PutString("\nOperator1");
        *(*(operandi+0)+i) = *(unos+i);
        i++;
    }

    *(*(operandi+0)+i) = '\0';  // kraj stringa prvog operanda
    *operator = *(unos+i);      // Kada while zavrsi, to znaci da je naisao na operator

    // Pretpostavljam ispravan unos, jedan operand. Ovo ga preskace.
    i++;

    while(
        *(unos+i) != 'A' &&
        *(unos+i) != 'B' &&
        *(unos+i) != 'C' &&
        *(unos+i) != 'D' &&
        *(unos+i) != '*' &&
        *(unos+i) != '#' &&
        *(unos+i) != '\0'       // Sada provjeravas da li je dosao do kraja
    ) {
        //UART0_PutString("\nOperator2");
        *(*(operandi+1)+j) = *(unos+i);
        i++;
        j++;
    }

    *(*(operandi+1)+j) = '\0';  // kraj stringa drugog operanda

    // nije najkulturnije da se ovo radi ode pa posle opet nesto slicno
    // ali sluzi svrsi
    switch(*operator) {
        case 'A': *operator = '+'; break;
        case 'B': *operator = '-'; break;
        case 'C': *operator = '*'; break;
        case 'D': *operator = '/'; break;
    }

}

/*
 * Posto su svi objekti globalni, ne moram da radim sa pokazivacima
 * nije moralo ni u prethodnoj funkciji.
 */
int racunaj() {
    switch(operator) {
        case '+': return atoi(operandi[0]) + atoi(operandi[1]);
        case '-': return atoi(operandi[0]) - atoi(operandi[1]);
        case '*': return atoi(operandi[0]) * atoi(operandi[1]);
        case '/': return atoi(operandi[0]) / atoi(operandi[1]);
    }
}

/*
 * 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;

        *(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
}


char Keypad_Scan()
{
 unsigned char col;
 XBR1 = 0x40; //dozvola crossbar-a i pull-up otpornika
 P1MDOUT = 0x00; //svi pinovi su open-drain
 for(col = 0x01; col != 0x10; col <<= 1)
 {
     P1MDIN = col | 0xf0; //nule u masci su HiZ pinovi
     P1 = ~col; //adresiranje kolone
     delay_ms(2);
     //visi nibl predstavlja kolonu, a nizi stanja tastera:
     switch((col << 4) | ((~P1) >> 4))
     {
         //prva kolona:
         case 0x11:
            return '1';
         case 0x12:
            return '2';
         case 0x14:
            return '3';
         case 0x18:
            return 'A';

         //druga kolona:
         case 0x21:
         return '4';
         case 0x22:
            return '5';
         case 0x24:
            return '6';
         case 0x28:
            return 'B';
         //treca kolona:
         case 0x41:
            return '7';
         case 0x42:
            return '8';
         case 0x44:
            return '9';
         case 0x48:
            return 'C';
         //cetvrta kolona:
         case 0x81:
            return '*';
         case 0x82:
            return '0';
         case 0x84:
            return '#';
         case 0x88:
            return 'D';
     }
 }
 return 0; //nije detektovan nijedan taster
}