CSC lab2

#include <reg515c.h>        // include fisierul reg515c.h, cu definitiile SFR
#define TRUE 1

#define EIGHT_BIT 1         // mod 1 - 10 biti (8 biti de date)
#define NINE_BIT 3          // mod 3 - 11 biti (9 biti de date)

void StartDelay(int ms);
unsigned char UsartInit(unsigned int baudrate, unsigned char mode);     // initializare USART
void UsartSendChar(unsigned char ch);               // transmisie caracter
void UsartSendMessage(unsigned char *mesaj);
int UsartReceiveChar(unsigned int timeout);
void Timer0Init(void);

unsigned int timeval;
unsigned char timeout;
unsigned char* ptr;
unsigned int flag_R = 0;
void main(void){    // programul principal

    SWDT=1;         // pornire ceas de garda - WDT prin program.
                    // WDT porneste automat la lansarea simulatorului,
                    //  deoarece pinul simulat PE_SWD=1 la pornirea simulatorului.
                    // Odata pornit, WDT nu mai poate fi dezactivat prin program.
                    // Dacã nu vrem sa folosim WDT în programul simulat, atunci se forteaza
                    //  din simulator PE_SWD=0 si se reseteaza CPU.
                    // Cele doua comenzi se pun intr-un fisier de comenzi pe care simulatorul este instruit
                    //  sa-l incarce la pornire.

    Timer0Init();

    UsartInit(9600, EIGHT_BIT);     // 9600 baud, 8 biti de date
    EAL=1;              // validare globala intreruperi

    StartDelay(2000);                   // asteapta 1 secunda

    while(TRUE){

        if(timeout){
            UsartSendMessage(UsartReceiveChar(1000));           // transmite caracter
            UsartSendMessage("abc\n\r");            // transmite caracter
            StartDelay(2000);                   // asteapta 1 secunda
        }

        WDT=1;          // restart WDT - daca nu se utilizeaza aceasta secventa WDT reseteaza microcontrolerul
        SWDT=1;         // sunt necesare ambele comenzi pentru rearmarea WDT
    }
}


void Timer0Init(void){  // Initializare Timer 0
    TMOD=0x01;          // Timer 0 modul 1, pe 16 biti
    TL0=0x7E;
    TH0=0xF9;           // Temporizare 1 ms (TH0:TL0=65536-1666 =0xF97E la 10 MHz, cu factor de divizare 6)
    ET0=1;              // Validare intreruperi Timer 0
    timeout=1;
}

void Timer0Handler (void) interrupt 1{      // functia de intrerupere la depasire Timer 0
    TL0=0x7E;
    TH0=0xF9;                               // reincarca numaratorul pentru 1 ms
    if(timeval) timeval--;                  // decrementeaza timeval daca este diferit de 0
    else{
        TR0=0;
        timeout=1;
    }                               // daca timeval=0, opreste timerul 0
}

void UsartHandler (void) interrupt 4 {      // functia de intrerupere la depasire Timer 0
    if(TI) {
        TI=0;
        if (*ptr) UsartSendChar(*ptr++);
    }
    if(RI) {
        RI=0;
        flag_R = 1;
    }
}

void StartDelay(int ms){                   // intarziere programabila
    timeout=0;
    timeval=ms;                    // initializeaza timeval
    TR0=1;                         // porneste timerul 0
}


unsigned char UsartInit(unsigned int baudrate, unsigned char mode){         // initializare USART
    switch(mode){
        case EIGHT_BIT:  SCON = 0x52; break;     // mod 1, REN=1, TI=1, RI=0
        case NINE_BIT:   SCON = 0xD2; break;     // mod 3, REN=1, TI=1, RI=0
        default:    return 1;
    }
    switch(baudrate){
        case 4800:  SRELH = 0x03;      // factorul de divizare = 0x03BF
                    SRELL = 0xBF;
                    PCON &= 0x00;      // SMOD = 0
                    break;
        case 9600:  SRELH = 0x03;      // factorul de divizare = 0x03DF
                    SRELL = 0xDF;
                    PCON &= 0x00;      // SMOD = 0
                    break;
        case 19200: SRELH = 0x03;      // factorul de divizare = 0x03DF
                    SRELL = 0xDF;
                    PCON |= 0x80;      // SMOD = 1
                    break;
        case 57600: SRELH = 0x03;      // factorul de divizare = 0x03F5
                    SRELL = 0xF5;
                    PCON |= 0x80;      // SMOD = 1
                    break;
        default: return 2;             // eroare - baudrate necunoscut
    }
    ADCON0 |= 0x80;                     // Valideaza generatorul intern de tact pentru seriala BD=1
    TI=0;
    ES=1;                               // Validare intreruperi USART
    return 0;                           // succes
}

void UsartSendChar(unsigned char ch){ // transmisie character
    SBUF = ch;          // scrie caracterul de transmis in buffer
}

void UsartSendMessage(unsigned char *mesaj) {
    ptr = mesaj;
    UsartSendChar(*ptr++);
}

int UsartReceiveChar(unsigned int timeout) {
    char m = '0';
    flag_R = 0;
    StartDelay(timeout);
    while (timeout == 0 && flag_R == 0) {
        WDT = 1;
        SWDT = 1;
    }
    if (flag_R) {
        m = SBUF;
        return m;
    }
    else return 0;
}